def test_partial_fit_model_dict_wrong_type(): """Test either if an error is raised when a parameters is a wrong type in the dictionary.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'gt_folders', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to make the normalization stn = StandardTimeNormalization(dce_mod) params = {'std': 50., 'exp': 25., 'alpha': .9, 'max_iter': 5.} assert_raises(ValueError, stn.partial_fit_model, dce_mod, ground_truth=gt_mod, cat=label_gt[0], params=params) params = {'std': 50., 'exp': 25, 'alpha': .9, 'max_iter': 5} assert_raises(ValueError, stn.partial_fit_model, dce_mod, ground_truth=gt_mod, cat=label_gt[0], params=params)
def test_read_gt_data_path_list_constructor(): """ Test if we can read gt series. """ # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'gt_folders') path_data_list = [os.path.join(path_data, 'prostate'), os.path.join(path_data, 'cg'), os.path.join(path_data, 'pz'), os.path.join(path_data, 'cap')] # Give the list for the ground_truth label = ['prostate', 'cg', 'pz', 'cap'] # Create an object to handle the data gt_mod = GTModality(path_data_list) # Check that the data have been read assert_true(not gt_mod.is_read()) gt_mod.read_data_from_path(label) # Check that the data have been read assert_true(gt_mod.is_read()) # Check the data here data = np.load(os.path.join(currdir, 'data', 'gt_path_list.npy')) assert_array_equal(gt_mod.data_, data) assert_equal(gt_mod.n_serie_, 4)
def test_extract_index(): """ Test if the indexes of a GT will be well extracted. """ # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'gt_folders') path_data_list = [os.path.join(path_data, 'prostate'), os.path.join(path_data, 'cg'), os.path.join(path_data, 'pz'), os.path.join(path_data, 'cap')] # Give the list for the ground_truth label = ['prostate', 'cg', 'pz', 'cap'] # Create an object to handle the data gt_mod = GTModality() # Read the data gt_mod.read_data_from_path(label, path_data=path_data_list) # Extract the prostate indexes label_extr = 'prostate' idx_prostate = gt_mod.extract_gt_data(label_extr, 'index') data = np.load(os.path.join(currdir, 'data', 'extract_gt_index.npy')) # Check each table for idx_arr, test_arr in zip(idx_prostate, data): assert_array_equal(idx_arr, test_arr)
def test_shift_heatmap_wrong_shift(): """Test if an error is raised when the shidt provided is not consistent.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'gt_folders', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Build a heatmap from the dce data # Reduce the number of bins to enforce low memory consumption nb_bins = [100] * dce_mod.n_serie_ heatmap, bins_heatmap = dce_mod.build_heatmap(gt_mod.extract_gt_data( label_gt[0]), nb_bins=nb_bins) # Create a list of shift which do not have the same number of entries # than the heatmap - There is 4 series, let's create only 2 shift_arr = np.array([10] * 2) assert_raises(ValueError, StandardTimeNormalization._shift_heatmap, heatmap, shift_arr)
def test_partial_fit_model_2(): """Test the routine to fit two models.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'full_dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'full_gt', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to make the normalization stn = StandardTimeNormalization(dce_mod) stn.partial_fit_model(dce_mod, gt_mod, label_gt[0]) stn.partial_fit_model(dce_mod, gt_mod, label_gt[0]) # Check the model computed model_gt = np.array([22.26479174, 22.51070962, 24.66027277, 23.43488237, 23.75601817, 22.56173871, 26.86244505, 45.06227804, 62.34273874, 71.35327656]) assert_array_almost_equal(stn.model_, model_gt, decimal=PRECISION_DECIMAL) assert_true(stn.is_model_fitted_)
def test_shift_heatmap(): """Test the routine which shift the heatmap.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'gt_folders', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Build a heatmap from the dce data # Reduce the number of bins to enforce low memory consumption nb_bins = [100] * dce_mod.n_serie_ heatmap, bins_heatmap = dce_mod.build_heatmap(gt_mod.extract_gt_data( label_gt[0]), nb_bins=nb_bins) # Create a list of shift which do not have the same number of entries # than the heatmap - There is 4 series, let's create only 2 shift_arr = np.array([10] * 4) heatmap_shifted = StandardTimeNormalization._shift_heatmap(heatmap, shift_arr) data = np.load(os.path.join(currdir, 'data', 'heatmap_shifted.npy')) assert_array_equal(heatmap_shifted, data)
def test_denormalize_wt_fitting(): """Test either an error is raised if the data are not fitted first.""" # Create a T2WModality object currdir = os.path.dirname(os.path.abspath(__file__)) path_data_t2w = os.path.join(currdir, 'data', 't2w') t2w_mod = T2WModality(path_data_t2w) t2w_mod.read_data_from_path() # Create the GTModality object path_data_gt = os.path.join(currdir, 'data', 'gt_folders') path_data_gt_list = [os.path.join(path_data_gt, 'prostate'), os.path.join(path_data_gt, 'pz'), os.path.join(path_data_gt, 'cg'), os.path.join(path_data_gt, 'cap')] label_gt = ['prostate', 'pz', 'cg', 'cap'] gt_mod = GTModality() gt_mod.read_data_from_path(cat_gt=label_gt, path_data=path_data_gt_list) # Store the data before the normalization pdf_copy = t2w_mod.pdf_.copy() data_copy = t2w_mod.data_.copy() # Normalize the data gaussian_norm = GaussianNormalization(T2WModality()) assert_raises(ValueError, gaussian_norm.denormalize, t2w_mod)
def test_ese_transform_gt_cat(): """Test the transform routine with a given ground-truth.""" # Create the normalization object with the right modality dce_ese = EnhancementSignalExtraction(DCEModality()) # Try to fit an object with another modality currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Create an object to handle the data dce_mod = DCEModality() dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'gt_folders', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Fit and raise the error data = dce_ese.transform(dce_mod, gt_mod, label_gt[0]) # Check the size of the data assert_equal(data.shape, (12899, 4)) # Check the hash of the data data.flags.writeable = False assert_equal(hash(data.data), -3808597525488161265)
def test_save_model_wrong_ext(): """Test either if an error is raised if the filename as a wrong extension while storing the model.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'full_dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'full_gt', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to make the normalization stn = StandardTimeNormalization(dce_mod) stn.partial_fit_model(dce_mod, gt_mod, label_gt[0]) # Try to store the file not with an npy file assert_raises(ValueError, stn.save_model, os.path.join(currdir, 'data', 'model.rnd'))
def test_gn_fit_fix_mu_sigma(): """ Test the fitting routine with fixed mean and std. """ # Create a T2WModality object currdir = os.path.dirname(os.path.abspath(__file__)) path_data_t2w = os.path.join(currdir, 'data', 't2w') t2w_mod = T2WModality(path_data_t2w) t2w_mod.read_data_from_path() # Create the GTModality object path_data_gt = os.path.join(currdir, 'data', 'gt_folders') path_data_gt_list = [os.path.join(path_data_gt, 'prostate'), os.path.join(path_data_gt, 'pz'), os.path.join(path_data_gt, 'cg'), os.path.join(path_data_gt, 'cap')] label_gt = ['prostate', 'pz', 'cg', 'cap'] gt_mod = GTModality() gt_mod.read_data_from_path(cat_gt=label_gt, path_data=path_data_gt_list) params = {'mu': 200., 'sigma': 70.} gaussian_norm = GaussianNormalization(T2WModality(), params=params) gaussian_norm.fit(t2w_mod, gt_mod, label_gt[0]) assert_almost_equal(gaussian_norm.fit_params_['mu'], 245.90, decimal=DECIMAL_PRECISON) assert_almost_equal(gaussian_norm.fit_params_['sigma'], 74.31, decimal=DECIMAL_PRECISON)
def test_build_graph(): """Test the method to build a graph from the heatmap.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'gt_folders', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Build a heatmap from the dce data # Reduce the number of bins to enforce low memory consumption nb_bins = [100] * dce_mod.n_serie_ heatmap, bins_heatmap = dce_mod.build_heatmap(gt_mod.extract_gt_data( label_gt[0]), nb_bins=nb_bins) # Build the graph by taking the inverse exponential of the heatmap graph = StandardTimeNormalization._build_graph(heatmap, .5) graph_dense = graph.toarray() data = np.load(os.path.join(currdir, 'data', 'graph.npy')) assert_array_equal(graph_dense, data)
def test_rn_fit_fix_params(): """ Test the fitting routine with fixed parameters. """ # Create a T2WModality object currdir = os.path.dirname(os.path.abspath(__file__)) path_data_t2w = os.path.join(currdir, 'data', 't2w') t2w_mod = T2WModality(path_data_t2w) t2w_mod.read_data_from_path() # Create the GTModality object path_data_gt = os.path.join(currdir, 'data', 'gt_folders') path_data_gt_list = [os.path.join(path_data_gt, 'prostate'), os.path.join(path_data_gt, 'pz'), os.path.join(path_data_gt, 'cg'), os.path.join(path_data_gt, 'cap')] label_gt = ['prostate', 'pz', 'cg', 'cap'] gt_mod = GTModality() gt_mod.read_data_from_path(cat_gt=label_gt, path_data=path_data_gt_list) params = {'b': 200., 'off': 7., 'sigma': 80.} rician_norm = RicianNormalization(T2WModality(), params=params) rician_norm.fit(t2w_mod, gt_mod, label_gt[0]) assert_almost_equal(rician_norm.fit_params_['b'], 1.4463929678319398, decimal=DECIMAL_PRECISON) assert_almost_equal(rician_norm.fit_params_['off'], 0.12668917318976813, decimal=DECIMAL_PRECISON) assert_almost_equal(rician_norm.fit_params_['sigma'], 0.10331905081688209, decimal=DECIMAL_PRECISON)
def test_fit(): """Test the routine to fit the parameters of the dce normalization.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'full_dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'full_gt', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to make the normalization stn = StandardTimeNormalization(dce_mod) # Create a synthetic model to fit on stn.model_ = np.array([30., 30., 32., 31., 31., 30., 35., 55., 70., 80.]) stn.is_model_fitted_ = True # Fit the parameters on the model stn.fit(dce_mod, gt_mod, label_gt[0]) assert_almost_equal(stn.fit_params_['scale-int'], 1.2296657327848537, decimal=PRECISION_DECIMAL) assert_equal(stn.fit_params_['shift-time'], 0.0) data = np.array([191.29, 193.28, 195.28, 195.28, 195.28, 197.28, 213.25, 249.18, 283.12, 298.10]) assert_array_almost_equal(stn.fit_params_['shift-int'], data, decimal=PRECISION_DECIMAL)
def test_gn_wrong_size_gt(): """ Test either if an error is raised when the size of the ground-truth is different from the size of the base modality. """ # Create a T2WModality object currdir = os.path.dirname(os.path.abspath(__file__)) path_data_t2w = os.path.join(currdir, 'data', 't2w') t2w_mod = T2WModality(path_data_t2w) t2w_mod.read_data_from_path() # Create the GTModality object path_data_gt = os.path.join(currdir, 'data', 'gt_folders') path_data_gt_list = [os.path.join(path_data_gt, 'prostate'), os.path.join(path_data_gt, 'pz'), os.path.join(path_data_gt, 'cg'), os.path.join(path_data_gt, 'cap')] label_gt = ['prostate', 'pz', 'cg', 'cap'] gt_mod = GTModality() gt_mod.read_data_from_path(cat_gt=label_gt, path_data=path_data_gt_list) # Change the size of the data of the modality t2w_mod.data_ = t2w_mod.data_[:-1, :, :] gaussian_norm = GaussianNormalization(T2WModality()) assert_raises(ValueError, gaussian_norm.fit, t2w_mod, gt_mod, label_gt[0])
def test_qte_transform_regular(): """Test the transform function for regular model.""" # Try to fit an object with another modality currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, '../../preprocessing/tests/data/full_dce') # Create an object to handle the data dce_mod = DCEModality() dce_mod.read_data_from_path(path_data) # Create the gt data gt_mod = GTModality() gt_cat = ['cap'] path_data = [os.path.join( currdir, '../../preprocessing/tests/data/full_gt/cap')] gt_mod.read_data_from_path(gt_cat, path_data) # Create the object for the Tofts extraction tqe = ToftsQuantificationExtraction(DCEModality(), 1.6, 3.5, random_state=RND_SEED) tqe.fit(dce_mod) data = tqe.transform(dce_mod, gt_mod, gt_cat[0], kind='regular') data_gt = np.load(os.path.join(currdir, 'data/tofts_reg_data.npy')) assert_array_almost_equal(data, data_gt, decimal=DECIMAL_PRECISION)
def find_normalization_params(pat_t2w, pat_gt, label): # Create the normalization object and load the model t2w_norm = RicianNormalization(T2WModality()) # Read the T2W t2w_mod = T2WModality() t2w_mod.read_data_from_path(pat_t2w) # Read the GT gt_mod = GTModality() gt_mod.read_data_from_path(label, pat_gt) # Find the normalization parameters t2w_norm.fit(t2w_mod, ground_truth=gt_mod, cat=label[0]) return t2w_norm
def test_check_modality_gt_not_read(): """Test if an error is raised when the gt is not read.""" # Try to fit an object with another modality currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 't2w') # Create an object to handle the data t2w_mod = T2WModality() # Load the GT data path_gt = [os.path.join(currdir, 'data', 'full_gt', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) assert_raises(ValueError, check_modality_gt, t2w_mod, gt_mod, label_gt[0])
def test_normalize_denormalize_3(): """Test the data normalization and denormalization with shift > 0.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'full_dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'full_gt', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to make the normalization stn = StandardTimeNormalization(dce_mod) # Simulate that we fitted the data stn.model_ = np.array([30., 30., 32., 31., 31., 30., 35., 55., 70., 80.]) stn.is_model_fitted_ = True stn.fit_params_ = {'scale-int': 1.2296657327848537, 'shift-time': 3.0, 'shift-int': np.array([191.29, 193.28, 195.28, 195.28, 195.28, 197.28, 213.25, 249.18, 283.12, 298.10])} stn.is_fitted_ = True # Store the data somewhere data_gt_cp = dce_mod.data_.copy() # Normalize the data dce_mod_norm = stn.normalize(dce_mod) # Check if the data are properly normalized dce_mod_norm.data_.flags.writeable = False data = np.load(os.path.join(currdir, 'data', 'data_normalized_dce_3.npy')) assert_equal(hash(dce_mod_norm.data_.data), data) dce_mod_norm.data_.flags.writeable = True dce_mod_2 = stn.denormalize(dce_mod_norm) dce_mod_2.data_.flags.writeable = False assert_equal(hash(dce_mod_2.data_.data), -3781160829709175881)
def find_normalization_params(pat_dce, pat_gt, label, pat_model): # Create the normalization object and load the model dce_norm = StandardTimeNormalization(DCEModality()) dce_norm.load_model(pat_model) # Read the DCE dce_mod = DCEModality() dce_mod.read_data_from_path(pat_dce) # Read the GT gt_mod = GTModality() gt_mod.read_data_from_path(label, pat_gt) # Find the normalization parameters dce_norm.fit(dce_mod, ground_truth=gt_mod, cat=label[0]) return dce_norm
def find_normalization_params(pat_adc, pat_gt, label, pat_model): # Create the normalization object and load the model adc_norm = PiecewiseLinearNormalization(ADCModality()) adc_norm.load_model(pat_model) # Read the ADC adc_mod = ADCModality() adc_mod.read_data_from_path(pat_adc) # Read the GT gt_mod = GTModality() gt_mod.read_data_from_path(label, pat_gt) # Find the normalization parameters adc_norm.fit(adc_mod, ground_truth=gt_mod, cat=label[0]) return adc_norm
def test_rn_normalize(): """ Test the normalize function. """ # Create a T2WModality object currdir = os.path.dirname(os.path.abspath(__file__)) path_data_t2w = os.path.join(currdir, 'data', 't2w') t2w_mod = T2WModality(path_data_t2w) t2w_mod.read_data_from_path() # Create the GTModality object path_data_gt = os.path.join(currdir, 'data', 'gt_folders') path_data_gt_list = [os.path.join(path_data_gt, 'prostate'), os.path.join(path_data_gt, 'pz'), os.path.join(path_data_gt, 'cg'), os.path.join(path_data_gt, 'cap')] label_gt = ['prostate', 'pz', 'cg', 'cap'] gt_mod = GTModality() gt_mod.read_data_from_path(cat_gt=label_gt, path_data=path_data_gt_list) # Store the data before the normalization pdf_copy = t2w_mod.pdf_.copy() data_copy = t2w_mod.data_.copy() # Normalize the data rician_norm = RicianNormalization(T2WModality()) rician_norm.fit(t2w_mod, gt_mod, 'prostate') t2w_mod = rician_norm.normalize(t2w_mod) # Check that the data are equal to what they should be assert_array_almost_equal(t2w_mod.data_, (data_copy - 253.284554765) / 70.2569459323, decimal=DECIMAL_PRECISON) # Denormalize the data t2w_mod = rician_norm.denormalize(t2w_mod) # Check that the data are equal to the original data data = np.load(os.path.join(currdir, 'data', 'data_rician_denormalize.npy')) assert_array_equal(t2w_mod.data_, data) data = np.load(os.path.join(currdir, 'data', 'pdf_rician_denormalize.npy')) assert_array_equal(t2w_mod.pdf_, data)
def test_read_gt_path(): """ Test if we can read data from the same folder organized with different serie ID. """ # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Give the list for the ground_truth label = ['prostate', 'pz'] # Create an object to handle the data gt_mod = GTModality() # Read the data gt_mod.read_data_from_path(label, path_data=path_data) # Check the data here data = np.load(os.path.join(currdir, 'data', 'gt_path.npy')) assert_array_equal(gt_mod.data_, data) assert_equal(gt_mod.n_serie_, 2)
def test_extract_wrong_output_type(): """ Test either if an error is raised if the type of output is unknown. """ # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'gt_folders') path_data_list = [os.path.join(path_data, 'prostate'), os.path.join(path_data, 'cg'), os.path.join(path_data, 'pz'), os.path.join(path_data, 'cap')] # Give the list for the ground_truth label = ['prostate', 'cg', 'pz', 'cap'] # Create an object to handle the data gt_mod = GTModality() # Read the data gt_mod.read_data_from_path(label, path_data=path_data_list) # Extract the prostate indexes label_extr = 'prostate' assert_raises(ValueError, gt_mod.extract_gt_data, label_extr, 'rnd')
def test_partial_fit_model_wt_label_gt(): """Test either if a warning is raised when a gt is not provided and a cat is.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'full_dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'full_gt', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to make the normalization stn = StandardTimeNormalization(dce_mod) assert_raises(ValueError, stn.partial_fit_model, dce_mod, gt_mod)
def test_fit_not_read_mod(): """Test either if an error is raised when the modality was not opened.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'full_dce') # Create an object to handle the data dce_mod = DCEModality() # Load the GT data path_gt = [os.path.join(currdir, 'data', 'full_gt', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() # Read the ground-truth gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to make the normalization stn = StandardTimeNormalization(dce_mod) assert_raises(ValueError, stn.partial_fit_model, dce_mod, gt_mod, label_gt[0])
def test_rn_fit_wrong_gt(): """ Test either if an error is raised when the wrong class is provided for the ground-truth. """ # Create a T2WModality object currdir = os.path.dirname(os.path.abspath(__file__)) path_data_t2w = os.path.join(currdir, 'data', 't2w') t2w_mod = T2WModality(path_data_t2w) t2w_mod.read_data_from_path() # Create the GTModality object path_data_gt = os.path.join(currdir, 'data', 'gt_folders') path_data_gt_list = [os.path.join(path_data_gt, 'prostate'), os.path.join(path_data_gt, 'pz'), os.path.join(path_data_gt, 'cg'), os.path.join(path_data_gt, 'cap')] label_gt = ['prostate', 'pz', 'cg', 'cap'] gt_mod = GTModality() gt_mod.read_data_from_path(cat_gt=label_gt, path_data=path_data_gt_list) rician_norm = RicianNormalization(T2WModality()) assert_raises(ValueError, rician_norm.fit, t2w_mod, t2w_mod, label_gt[0])
def test_ese_wrong_gt_size(): """Test if an error is raised when the size of gt is not consistent with the modality.""" # Create the normalization object with the right modality dce_ese = EnhancementSignalExtraction(DCEModality()) # Try to fit an object with another modality currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Create an object to handle the data dce_mod = DCEModality() dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'full_gt', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Fit and raise the error assert_raises(ValueError, dce_ese.transform, dce_mod, gt_mod, label_gt[0])
def test_ese_transform_gt_no_cat(): """Test eihter if an error is raised when no category for GT is provided.""" # Create the normalization object with the right modality dce_ese = EnhancementSignalExtraction(DCEModality()) # Try to fit an object with another modality currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Create an object to handle the data dce_mod = DCEModality() dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'gt_folders', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Fit and raise the error assert_raises(ValueError, dce_ese.transform, dce_mod, gt_mod)
def test_gn_wrong_label_gt(): """ Test either if an error is raised when the category label asked was not load by the GTModality. """ # Create a T2WModality object currdir = os.path.dirname(os.path.abspath(__file__)) path_data_t2w = os.path.join(currdir, 'data', 't2w') t2w_mod = T2WModality(path_data_t2w) t2w_mod.read_data_from_path() # Create the GTModality object path_data_gt = os.path.join(currdir, 'data', 'gt_folders') path_data_gt_list = [os.path.join(path_data_gt, 'prostate'), os.path.join(path_data_gt, 'pz'), os.path.join(path_data_gt, 'cg'), os.path.join(path_data_gt, 'cap')] label_gt = ['prostate', 'pz', 'cg', 'cap'] gt_mod = GTModality() gt_mod.read_data_from_path(cat_gt=label_gt, path_data=path_data_gt_list) gaussian_norm = GaussianNormalization(T2WModality()) assert_raises(ValueError, gaussian_norm.fit, t2w_mod, gt_mod, 'None')
def test_partial_fit_model_wrong_string(): """Test either if an error is raised when the string is unknown.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'dce') # Create an object to handle the data dce_mod = DCEModality() # Read the data dce_mod.read_data_from_path(path_data) # Load the GT data path_gt = [os.path.join(currdir, 'data', 'gt_folders', 'prostate')] label_gt = ['prostate'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to make the normalization stn = StandardTimeNormalization(dce_mod) assert_raises(ValueError, stn.partial_fit_model, dce_mod, ground_truth=gt_mod, cat=label_gt[0], params='rnd')
def test_extract_no_label_known(): """Test either if an error is raised when no corresponding gt category is found.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 'gt_folders') path_data_list = [os.path.join(path_data, 'prostate'), os.path.join(path_data, 'cg'), os.path.join(path_data, 'pz'), os.path.join(path_data, 'cap')] # Give the list for the ground_truth label = ['prostate', 'cg', 'pz', 'cap'] # Create an object to handle the data gt_mod = GTModality() # Read the data gt_mod.read_data_from_path(label, path_data=path_data_list) # Try to extract a wrong label label_extr = 'rnd' assert_raises(ValueError, gt_mod.extract_gt_data, label_extr)
def test_get_pdf_roi(): """Test the routine to get pdf and bins with a given roi.""" # Load the data with only a single serie currdir = os.path.dirname(os.path.abspath(__file__)) path_data = os.path.join(currdir, 'data', 't2w') # Create an object to handle the data t2w_mod = T2WModality() t2w_mod.read_data_from_path(path_data) path_data = os.path.join(currdir, 'data', 'gt_folders') path_data_list = [os.path.join(path_data, 'prostate'), os.path.join(path_data, 'cg'), os.path.join(path_data, 'pz'), os.path.join(path_data, 'cap')] # Give the list for the ground_truth label = ['prostate', 'cg', 'pz', 'cap'] # Create an object to handle the data gt_mod = GTModality() # Read the data gt_mod.read_data_from_path(label, path_data=path_data_list) # Extract the prostate indexes label_extr = 'prostate' data_prostate = gt_mod.extract_gt_data(label_extr, 'index') # Compute the hisogram with a wrong argument as string pdf_data, bin_data = t2w_mod.get_pdf(roi_data=data_prostate) # Check that the data correspond to the one save inside the the test data = np.load(os.path.join(currdir, 'data', 'bin_t2w_get_pdf_roi.npy')) assert_array_equal(bin_data, data) data = np.load(os.path.join(currdir, 'data', 'pdf_t2w_get_pdf_roi.npy')) assert_array_equal(pdf_data, data)
from protoclass.preprocessing import StandardTimeNormalization # Define the path for the DCE path_dce = '/data/prostate/experiments/Patient 383/DCE' # Define the list of path for the GT path_gt = ['/data/prostate/experiments/Patient 383/GT_inv/prostate'] # Define the associated list of label for the GT label_gt = ['prostate'] # Read the DCE dce_mod = DCEModality() dce_mod.read_data_from_path(path_dce) # Read the GT gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create the object to normalize the DCE data dce_norm = StandardTimeNormalization(dce_mod) # Fit the data to get the normalization parameters dce_norm.partial_fit_model(dce_mod, ground_truth=gt_mod, cat='prostate') print dce_norm.model_ # Define the path for the DCE path_dce = '/data/prostate/experiments/Patient 387/DCE' # Define the list of path for the GT path_gt = ['/data/prostate/experiments/Patient 387/GT_inv/prostate']
# Load the original data path_t2w = '/data/prostate/experiments/Patient 1041/T2W' t2w_mod = T2WModality() t2w_mod.read_data_from_path(path_t2w) # Load the ground truth # Define the path of the ground for the prostate path_gt = [ '/data/prostate/experiments/Patient 1041/GT_inv/prostate', '/data/prostate/experiments/Patient 1041/GT_inv/pz', '/data/prostate/experiments/Patient 1041/GT_inv/cg', '/data/prostate/experiments/Patient 1041/GT_inv/cap' ] label_gt = ['prostate', 'pz', 'cg', 'cap'] gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_gt) # Create an empty volume of the size of the modality data prob_vol = np.zeros(t2w_mod.data_.shape) prob_ca = np.zeros(t2w_mod.data_.shape) # Extract the index of the prostate index prostate_idx = np.array(gt_mod.extract_gt_data('prostate')) ca_idx = np.array(gt_mod.extract_gt_data('cap')) for ii in range(ca_idx.shape[1]): coord = ca_idx[:, ii] prob_ca[coord[0], coord[1], coord[2]] = 1 # Assign the value in the volume
if os.path.isdir(os.path.join(path_patients, name)) ] for id_patient in id_patient_list: # Append for the GT data - Note that we need a list of gt path path_patients_list_gt.append( [os.path.join(path_patients, id_patient, gt) for gt in path_gt]) # Load all the data once. Splitting into training and testing will be done at # the cross-validation time data = [] label = [] for idx_pat in range(len(id_patient_list)): print 'Read patient {}'.format(id_patient_list[idx_pat]) # Create the corresponding ground-truth gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_patients_list_gt[idx_pat]) print 'Read the GT data for the current patient ...' # Load the approproate normalization object filename_hoffmann = (id_patient_list[idx_pat].lower().replace(' ', '_') + '_semi.npy') # Concatenate the training data # Select only the wash-in parameter data.append(np.load(os.path.join(path_hoffmann, filename_hoffmann))[:, 0]) # Extract the corresponding ground-truth for the testing data # Get the index corresponding to the ground-truth roi_prostate = gt_mod.extract_gt_data('prostate', output_type='index') # Get the label of the gt only for the prostate ROI gt_cap = gt_mod.extract_gt_data('cap', output_type='data')
# List where to store the different minimum list_min = [] list_max = [] for id_p, (p_t2w, p_gt) in enumerate(zip(path_patients_list_t2w, path_patients_list_gt)): # Remove a part of the string to have only the id nb_patient = id_patient_list[id_p].replace('Patient ', '') # Read the image data t2w_mod = T2WModality() t2w_mod.read_data_from_path(p_t2w) # Read the GT gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, p_gt) if not nb_patient == ID_GAUSSIAN: # Rician Normalization # Read the normalization information pat_chg = id_patient_list[id_p].lower().replace(' ', '_') + '_norm.p' filename = os.path.join(path_rician, pat_chg) t2w_norm = RicianNormalization.load_from_pickles(filename) # Normalize the data t2w_mod = t2w_norm.normalize(t2w_mod) else: # Gaussian Normalization
path_patients_list_gt.append([os.path.join(path_patients, id_patient, gt) for gt in path_gt]) # Load all the data once. Splitting into training and testing will be done at # the cross-validation time for idx_pat in range(len(id_patient_list)): print 'Read patient {}'.format(id_patient_list[idx_pat]) # Load the testing data that correspond to the index of the LOPO # Create the object for the DCE dce_mod = DCEModality() dce_mod.read_data_from_path(path_patients_list_dce[idx_pat]) print 'Read the DCE data for the current patient ...' # Create the corresponding ground-truth gt_mod = GTModality() gt_mod.read_data_from_path(label_gt, path_patients_list_gt[idx_pat]) print 'Read the GT data for the current patient ...' # Load the approproate normalization object filename_norm = (id_patient_list[idx_pat].lower().replace(' ', '_') + '_norm.p') dce_norm = StandardTimeNormalization.load_from_pickles( os.path.join(path_norm, filename_norm)) dce_mod = dce_norm.normalize(dce_mod) # Create the object to extrac data dce_ese = EnhancementSignalExtraction(DCEModality())