def test_radiomics(): # 文件名 main_path = '' ori_name = "/home1/quanquan/datasets/screencopy/nii/dynamic/0001.nii.gz" # r'\brain1_image.nrrd' lab_name = "/home1/quanquan/datasets/screencopy/nii/dynamic/seg0001.nii.gz" # r'\brain1_label.nrrd' para_name = '/home1/quanquan/datasets/screencopy/nii/dynamic/params.yaml' # 文件全部路径 ori_path = main_path + ori_name lab_path = main_path + lab_name para_path = main_path + para_name print("originl path: " + ori_path) print("label path: " + lab_path) print("parameter path: " + para_path) # 使用配置文件初始化特征抽取器 extractor = featureextractor.RadiomicsFeatureExtractor(para_path) print("Extraction parameters:\n\t", extractor.settings) # print ("Enabled filters:\n\t", extractor._enabledImagetypes) # print ("Enabled features:\n\t", extractor._enabledFeatures) # 运行 result = extractor.execute(ori_path, lab_path) #抽取特征 print("Result type:", type(result)) # result is returned in a Python ordered dictionary print("") print("Calculated features") for key, value in result.items(): #输出特征 print("\t", key, ":", value)
def CalculationRun(imageName,maskName,paramsFile): if imageName is None or maskName is None: # Something went wrong, in this case PyRadiomics will also log an error print('Error getting testcase!') exit() # Regulate verbosity with radiomics.verbosity # radiomics.setVerbosity(logging.INFO) # # Get the PyRadiomics logger (default log-level = INFO # logger = radiomics.logger # logger.setLevel(logging.DEBUG) # set level to DEBUG to include debug log messages in log file # # Write out all log entries to a file # handler = logging.FileHandler(filename='testLog.txt', mode='w') # formatter = logging.Formatter("%(levelname)s:%(name)s: %(message)s") # handler.setFormatter(formatter) # logger.addHandler(handler) # Initialize feature extractor using the settings file extractor = featureextractor.RadiomicsFeatureExtractor(paramsFile) # Uncomment one of these functions to show how PyRadiomics can use the 'tqdm' or 'click' package to report progress when # running in full python mode. Assumes the respective package is installed (not included in the requirements) #print("Calculating features:") featureVector = extractor.execute(imageName, maskName) return featureVector
def T1c(): ori_path = ".\\" + entry1.get() lab_path = entry5.get() para_path = r'.\param.yaml' #初始化特征提取器 extractor = FEE.RadiomicsFeatureExtractor(para_path) #提取特征 result = extractor.execute(ori_path, lab_path) T1C_value = ( (-0.0879) * (result['log-sigma-5-0-mm-3D_glszm_GrayLevelNonUniformityNormalized'] - 0.0496722822023121) / 0.016580929209522 + (-0.0198) * (result['wavelet-LLH_gldm_DependenceVariance'] - 2.80000997710982) / 2.48108709989194 + (-0.0347) * (result['wavelet-LHL_firstorder_Minimum'] + 230.038254390231) / 100.059373429889 + (-0.0048) * (result['wavelet-LHL_glszm_GrayLevelNonUniformityNormalized'] - 0.0280935086820809) / 0.0083008353540124 + (0.0113) * (result['wavelet-LHH_glcm_MaximumProbability'] - 0.0639668250057803) / 0.0347979260652301 + (-0.0363) * (result['wavelet-HLL_firstorder_Entropy'] - 5.31659457573988) / 0.496598183048982 + (0.0031) * (result['wavelet-HLL_firstorder_Uniformity'] - 0.0345500586589595) / 0.0127316075058006 + (-0.0470) * (result['wavelet-HLL_glszm_LargeAreaLowGrayLevelEmphasis'] - 0.0180893810693641) / 0.0302961747308273 + (0.0636) * (result['wavelet-HLH_firstorder_Mean'] - 0.0637406382138728) / 1.05561873005995 + (0.0010) * (result['wavelet-HHL_glrlm_ShortRunEmphasis'] - 0.967566985641618) / 0.0154068102509531 + (-0.0279) * (result['wavelet-HHL_gldm_DependenceVariance'] - 1.92187294864161) / 1.69262435797558 + (0.0211) * (result['wavelet-HHH_firstorder_Maximum'] - 50.315030553971) / 23.9348605640564) return T1C_value
def EstrattoreFeaturesDose(Image_path, Mask_path, Output_path): Maskstk = sitk.ReadImage(Mask_path) Imagestk = sitk.ReadImage(Image_path) DOSE_size = Imagestk.GetSize() DOSE_spacing = Imagestk.GetSpacing() DOSE_depth = Imagestk.GetDepth() DOSE_dimension = Imagestk.GetDimension() DOSE_direction = Imagestk.GetDirection() DOSE_numberofpixels = Imagestk.GetNumberOfPixels() DOSE_origin = Imagestk.GetOrigin() DOSE_scaling = Imagestk.GetMetaData('3004|000e') Imagestk_np = sitk.GetArrayFromImage(Imagestk) Imagestk_np1 = Imagestk_np * float(DOSE_scaling) Imagestk_1 = sitk.GetImageFromArray(Imagestk_np1) Imagestk_1.SetSpacing(DOSE_spacing) Imagestk_1.SetDirection(DOSE_direction) Imagestk_1.SetOrigin(DOSE_origin) extractor = featureextractor.RadiomicsFeatureExtractor(binWidth=1, correctMask=True) result = extractor.execute(Imagestk_1, Maskstk) import pandas as pd features = {} for key, value in result.items(): features[key] = value df = pd.DataFrame(result.items()) df.to_csv(Output_path)
def singleExtract_BMP(self, imageName, maskName, params): try: extractor = featureextractor.RadiomicsFeatureExtractor(params) color_channel = 0 im = sitk.ReadImage(imageName) selector = sitk.VectorIndexSelectionCastImageFilter() selector.SetIndex(color_channel) im = selector.Execute(im) color_channel = 0 mas = sitk.ReadImage(maskName) selector = sitk.VectorIndexSelectionCastImageFilter() selector.SetIndex(color_channel) mas = selector.Execute(mas) result = extractor.execute(im, mas) feature = {key: val for key, val in six.iteritems(result)} except Exception as e: print(e) print("error when extacting ", imageName) feature = None return feature
def get_features(img_arr): data = list() image = img_arr[..., np.newaxis] label = np.ones(shape=image.shape) extractor = featureextractor.RadiomicsFeatureExtractor() extractor.disableAllFeatures() extractor.enableFeatureClassByName('firstorder') extractor.enableFeatureClassByName('glcm') extractor.enableFeatureClassByName('glrlm') extractor.enableFeatureClassByName('ngtdm') extractor.enableFeatureClassByName('gldm') image_path_to = './tmp/tmp_img.nrrd' label_path_to = './tmp/tmp_label.nrrd' nrrd.write(image_path_to, image) nrrd.write(label_path_to, label) result = extractor.execute(image_path_to, label_path_to) data.append(result) df = pd.DataFrame(data, dtype=np.float) return df[X_FEATURES]
def extract(imagePath, maskPath, paramfilepath, tempDir): """ RKP - 3/20/2018 Wrapper function for calculation of a radiomics features using pyradiomics. """ # Read image and mask print('Reading image and mask...') if imagePath is None or maskPath is None: # Something went wrong, in this case PyRadiomics will also log an error print('Error reading input image and mask') exit() # Instantiate the extractor using the settings file print('Initializing feature extractor...') extractor = featureextractor.RadiomicsFeatureExtractor(paramfilepath) print('Done.') #Load and pre-process image and mask image, mask = extractor.loadImage(imagePath, maskPath) #image = sitk.ReadImage(imagePath) #mask = sitk.ReadImage(maskPath) # Calc features result = extractor.execute(image, mask) # Adjust fieldnames newResult = adjustKeyNames(result) return newResult
def EstrattoreFeaturesADC(path_list, bin_Count): list_path = [line.split() for line in open(path_list, 'r')] for i in range(len(list_path)): Output_path = list_path[i][2] Mask_path = list_path[i][1] Image_path = list_path[i][0] print(Output_path) print(Mask_path) print(Image_path) Maskstk = sitk.ReadImage(Mask_path) Imagestk = sitk.ReadImage(Image_path) extractor = featureextractor.RadiomicsFeatureExtractor( binCount=bin_Count, correctMask=True) result = extractor.execute(Imagestk, Maskstk) features = {} for key, value in result.items(): features[key] = value df = pd.DataFrame(result.items()) df.to_csv(Output_path)
def extract_features_from_image(imagePath, maskPath, paramsPath): """ ACTION: Extract radiomic features from one image, given mask and parameters, and return a dictionary with the feature values INPUT: imagePath: path to image nrrd-file (without extension) maskPath: path to mask nrrd-file (without extension) paramsPath: path to file with radiomic feature extraction settings OUTPUT: dictionary with all extracted features """ img = imagePath + ".nrrd" mask = maskPath + ".nrrd" if not os.path.isfile(img): raise IOError('File does not exist: %s' % img) elif not os.path.isfile(mask): raise IOError('File does not exist: %s' % mask) elif not os.path.isfile(paramsPath): raise IOError('File does not exist: %s' % paramsPath) extractor = featureextractor.RadiomicsFeatureExtractor(paramsPath) setVerbosity( 40 ) # Set level of verbosity, 40=Errors, 30=Warnings, 20=Info, 10=Debug results = extractor.execute(img, mask) return results
def one_featureExtraction(ori_path, lab_path, para_path): # Initial feature extractor by using para file extractor = FEE.RadiomicsFeatureExtractor(para_path) # Execute the extractor # Features extraction: results is returned in a Python ordered dictionary current_result = extractor.execute(ori_path, lab_path) return current_result
def get_radiomics_df(path, patient_hash, nrrd_file_path, mask_folder_path): """ Run pyradiomics and return pandas dataframe with all the computed data. :param path: Path to patient directory (str). :param patient_hash: Patient hash ID generated from their identifiers. :param nrrd_file_path: Path to folder with converted nrrd file. :param mask_folder_path: Path to ROI nrrd files. :return: Pandas dataframe. """ # Initialize feature extractor using default pyradiomics settings extractor = featureextractor.RadiomicsFeatureExtractor() # Contains the features for all the ROI all_features = [] # CSV headers radiomics_headers = [] feature_vector = '' # If RTSS selected has no ROIS if not os.listdir(mask_folder_path): return None for file in os.listdir(mask_folder_path): # Contains features for current ROI roi_features = [] roi_features.append(patient_hash) roi_features.append(path) # Full path of ROI nrrd file mask_name = mask_folder_path + '/' + file # Name of ROI image_id = file.split('.')[0] feature_vector = extractor.execute(nrrd_file_path, mask_name) roi_features.append(image_id) # Add first order features to list for feature_name in feature_vector.keys(): roi_features.append(feature_vector[feature_name]) all_features.append(roi_features) radiomics_headers.append('Hash ID') radiomics_headers.append('Directory Path') radiomics_headers.append('ROI') # Extract column/feature names for feature_name in feature_vector.keys(): radiomics_headers.append(feature_name) # Convert into dataframe radiomics_df = pd.DataFrame(all_features, columns=radiomics_headers) radiomics_df.set_index('Hash ID', inplace=True) return radiomics_df
def get_texture_features(roi_gray, mask): """ Extract texture features from ROI Parameters ---------- roi_gray Region of interest of the image (gray scale) mask Binary version of the ROI Returns ------- texture_features All extracted texture features of a ROI """ # First, get GLRLM features data_spacing = [1, 1, 1] # Convert numpy arrays to sitk so that extractor.execute can be employed for GLRLM features sitk_img = sitk.GetImageFromArray(roi_gray) sitk_img.SetSpacing((float(data_spacing[0]), float(data_spacing[1]), float(data_spacing[2]))) sitk_img = sitk.JoinSeries(sitk_img) mask_mod = mask + 1 sitk_mask = sitk.GetImageFromArray(mask_mod) sitk_mask.SetSpacing((float(data_spacing[0]), float(data_spacing[1]), float(data_spacing[2]))) sitk_mask = sitk.JoinSeries(sitk_mask) sitk_mask = sitk.Cast(sitk_mask, sitk.sitkInt32) # Parameters for radiomics extractor params = {} params['binWidth'] = 20 params['sigma'] = [1, 2, 3] params['verbose'] = True # For GLRLM features extractor = featureextractor.RadiomicsFeatureExtractor(**params) extractor.disableAllFeatures() extractor.enableFeatureClassByName('glrlm') result = extractor.execute(sitk_img, sitk_mask) glrlm_features_list = [] for key, value in result.items(): if 'glrlm' in key: glrlm_features_list.append(value.item()) glrlm_features = np.array(glrlm_features_list) masked_roi = bring_to_256_levels(np.multiply(roi_gray, mask)) textures = mt.features.haralick(masked_roi, ignore_zeros=True) haralick_features = textures.mean(axis=0) texture_features = np.concatenate((haralick_features, glrlm_features), axis=0) return texture_features
def get_extractor(param=None): global PARAM if param is None: params = PARAM else: params = param extractor = featureextractor.RadiomicsFeatureExtractor(params) extractor.settings['geometryTolerance'] = 1e-4 # extractor.enableCExtensions(True) extractor.enableFeatureClassByName('shape') return extractor
def singleExtract_NII(self, imageName, maskName, params): try: extractor = featureextractor.RadiomicsFeatureExtractor(params) result = extractor.execute(imageName, maskName) feature = {key: val for key, val in six.iteritems(result)} except Exception as e: print(e) print("error when extacting ", imageName) feature = None return feature
def __init__(self, radiomics_parameter_file, has_label=True, ignore_tolerence=False, ignore_diagnostic=True): self.feature_values = [] self.case_list = [] self.feature_name_list = [] self.extractor = featureextractor.RadiomicsFeatureExtractor(radiomics_parameter_file) self.error_list = [] self.logger = eclog(os.path.split(__file__)[-1]).GetLogger() self.__has_label = has_label self.__is_ignore_tolerence = ignore_tolerence self.__is_ignore_diagnostic = ignore_diagnostic self.error_list = []
def get_features(): false_dataPath = r'E:\data\No2HospitalProstate\buliangbingli\binglishengjiF' positive_dataPath = r'E:\data\No2HospitalProstate\buliangbingli\binglishengjiP' featureExcelPath = './No2Hospital_binglishengji_features.csv' paramPath = './Params.yaml' yaml_params = {'binWidth': 20, 'sigma': [1, 2, 3], 'verbose': True} # Instantiate the extractor extractor = featureextractor.RadiomicsFeatureExtractor(**yaml_params) # extractor.enableInputImageByName('LoG') extractor.disableAllFeatures() extractor.enableFeatureClassByName('firstorder') extractor.enableFeaturesByName( glcm=['Autocorrelation', 'Homogeneity1', 'SumSquares']) extractor = featureextractor.RadiomicsFeatureExtractor(paramPath) false_feature_values, t2_feature_names, adc_feature_names = loop_different_folds( false_dataPath, '0', extractor) positive_feature_values, _, _ = loop_different_folds( positive_dataPath, '1', extractor) total_feature_values = false_feature_values + positive_feature_values total_feature_keys = ['CaseName', 'label' ] + t2_feature_names + adc_feature_names df = pd.DataFrame(total_feature_values, columns=total_feature_keys) df.to_csv(featureExcelPath, index=False)
def calculate(self, image: sitk.Image, mask: sitk.Image, json_parms: str) -> pyradiomics_response: """[Trigger pyRadiomics calculation] Args: image (sitk.Image): [Input Image] mask (sitk.Image): [Input mask] Returns: pyradiomics_response: [Handler for pyRadiomics reponse] """ extractor = featureextractor.RadiomicsFeatureExtractor() extractor.loadJSONParams(json_parms) results = extractor.execute(image, mask) return pyradiomics_response(results)
def radiomics_extract(df, mode, idxs, path_img='../Images_nrrd', path_seg='../label'): """contains the radiomics feature extraction""" set_path = './pyradiomics_settings.yaml' extractor = featureextractor.RadiomicsFeatureExtractor(set_path) df_list = [] except_dict = { 'idx': [], } for idx in tqdm(idxs): # get current filename o = df.iloc[idx] file = o[F_KEY] # get the two relevant paths for image and segmentation picpath = f'{path_img}/{file}.nrrd' nrrdpath = f'{path_seg}/{file}.nrrd' print(picpath) print(nrrdpath) # obtain result result = extractor.execute(picpath, nrrdpath) # compress df_loc = result2compresdf(result) # append the label df_loc['label1'] = o[CLASS_KEY] df_loc['label2'] = o[ENTITY_KEY] df_list.append(df_loc.copy()) df_rad = df_list[0] df_except = pd.DataFrame.from_dict(except_dict, orient='index') for i, df_loc in enumerate(df_list): if i > 0: df_rad = df_rad.append(df_loc) # finnaly save result df_rad.to_csv(f'../radiomics/{mode}.csv') df_except.to_csv(f'../radiomics/{mode}-except.csv')
def extract_features(self, params_file, loggenabled=False): if self._data_type == 'nrrd': #set up pyradiomics if loggenabled: logger = radiomics.logger logger.setLevel( logging.DEBUG ) # set level to DEBUG to include debug log messages in log file # Write out all log entries to a file handler = logging.FileHandler(filename='test_log.txt', mode='w') formatter = logging.Formatter( "%(levelname)s:%(name)s: %(message)s") handler.setFormatter(formatter) logger.addHandler(handler) # Initialize feature extractor using the settings file feat_dictionary, key_number = {}, 0 extractor = featureextractor.RadiomicsFeatureExtractor(params_file) for pat, path in tqdm(self, desc='Patients processed'): try: temp_data = sitk.ReadImage(path[0]) temp_mask = sitk.ReadImage(path[1]) pat_features = extractor.execute(temp_data, temp_mask) if pat_features['diagnostics_Image-original_Hash'] != '': pat_features.update({ 'Patient': pat, 'ROI': path[1].split('\\')[-1][:-5] }) feat_dictionary[key_number] = pat_features key_number += 1 except KeyboardInterrupt: raise except: warn('region : %s skipped' % pat) output_features = DataFrame.from_dict(feat_dictionary).T return output_features else: raise TypeError( 'The toolbox should be initialized with data_type = "nrrd"')
def ADC(): ori_path = entry4.get() lab_path = entry5.get() para_path = 'param.yaml' extractor = FEE.RadiomicsFeatureExtractor(para_path) result = extractor.execute(ori_path, lab_path) ADC_value = ( (-0.0437) * (result['wavelet-LHL_firstorder_Skewness'] + 0.660421803092485) / 1.02093354549596 + (-0.0140) * (result['wavelet-HLL_firstorder_Skewness'] + 0.740114255641618) / 0.84046517671544 + (-0.0983) * (result['wavelet-HLH_firstorder_Median'] + 0.538403181971098) / 8.43516762863539 + (0.0355) * (result['wavelet-HLH_firstorder_Skewness'] - 0.207093367872832) / 0.643958301754604) return ADC_value
def EstrattoreFeaturesCT(Image_path, Mask_path, Output_path, bW): Maskstk = sitk.ReadImage(Mask_path) Imagestk = sitk.ReadImage(Image_path) extractor = featureextractor.RadiomicsFeatureExtractor(binWidth=bW, correctMask=True) result = extractor.execute(Imagestk, Maskstk) import pandas as pd features = {} for key, value in result.items(): features[key] = value df = pd.DataFrame(result.items()) df.to_csv(Output_path)
def init_extractor(): # First define the settings settings = {} settings['force2D'] = True settings['binWidth'] = 1 # Instantiate the extractor extractor = featureextractor.RadiomicsFeatureExtractor( **settings) # ** 'unpacks' the dictionary in the function call # enable 2D shape extractor.enableFeatureClassByName('shape', False) extractor.enableFeatureClassByName('shape2D') #extractor.enableImageTypeByName('Wavelet') print('Enabled features:\n\t', extractor.enabledFeatures) # Still the default parameters return extractor
def extract_features_from_mask_helper(img, mk): image = sitk.GetImageFromArray(img) mask = sitk.GetImageFromArray(mk) # by default, it's 3d; so we need to change it extractor = featureextractor.RadiomicsFeatureExtractor(force2D=True) # Enables all feature classes extractor.enableAllFeatures() featureVector = extractor.execute(image, mask) # remove unnecessary parameter settings keys = list(featureVector.keys()) for k in keys[:10]: del featureVector[k] return featureVector
def T2flair(): ori_path = entry3.get() lab_path = entry5.get() para_path = 'param.yaml' extractor = FEE.RadiomicsFeatureExtractor(para_path) result = extractor.execute(ori_path, lab_path) T2Flair_value = ( (-0.0019) * (result['original_glrlm_LongRunHighGrayLevelEmphasis'] - 2240.14702016994) / 1113.75171862019 + (-0.0192) * (result['original_glszm_HighGrayLevelZoneEmphasis'] - 1662.55764616878) / 801.546612203378 + (-0.0517) * (result['log-sigma-3-0-mm-3D_glcm_ClusterShade'] - 99.099517136763) / 457.10325677393 + (0.0181) * (result['wavelet-LLH_firstorder_Median'] + 6.49869639713872) / 6.81144741424438 + (-0.0179) * (result['wavelet-HHH_firstorder_Mean'] + 0.00796741110982659) / 0.225955014528202) return T2Flair_value
def main(): # Get the location of the example settings file params = os.path.abspath(PARAMETERS_PATH) if not os.path.isfile(params): print("Failed to import parameters file.") return # Import the dataset cases = import_dataset() if not cases: print("Failed to import dataset.") return # Initialize feature extractor using the settings file extractor = featureextractor.RadiomicsFeatureExtractor(params) # Execute batch processing to extract features extract_features(extractor, cases, OUTPUT_PATH)
def radiomic_feature_extraction(casename,image_path,roi_path,save_dir,param_file='/home/kwl16/Projects/kwlqtim/mets_Params.yml'): params = param_file #replace with location of parameters file extractor = featureextractor.RadiomicsFeatureExtractor(params) #specify the image and roi path names and which case casename = casename image_path = image_path #replace with location of image file roi_path = roi_path #replace with location of roi file #load image and roi image = sitk.ReadImage(image_path) roi = sitk.ReadImage(roi_path) #check for presence of labels (1,2,3) in roi roi_arr = sitk.GetArrayFromImage(roi) #image -> array met_labels = np.unique(roi_arr)[1:] #which labels are present in the roi? radiomics_table = None for i, label in enumerate(met_labels): if len(np.where(roi_arr==label)[0]) <= 10: # remove tumors smaller than 10 voxels continue if len(np.unique(np.where(roi_arr==label)[0])) == 1 or len(np.unique(np.where(roi_arr==label)[1])) == 1 or len(np.unique(np.where(roi_arr==label)[2])) == 1: # drop 1-d, or 2-d ROIs continue label_mask = np.where(roi_arr == label) #identify where the label is in the original roi single_label_roi_arr = np.zeros(roi_arr.shape) #create a dummy roi single_label_roi_arr[label_mask] = 1 #assign a label of 1 in the dummy roi where the label was in the original roi single_label_roi = sitk.GetImageFromArray(single_label_roi_arr) #array -> image single_label_roi.CopyInformation(image) #extract features result = extractor.execute(image,single_label_roi) #put features in a table if radiomics_table is None: radiomics_table = pd.DataFrame(index=list(result.keys()) , columns = [label]).T radiomics_table.loc[label]=list(result.values()) save_path = save_dir #replace with location for file to be saved #save feature table radiomics_table.to_csv(os.path.join(save_path,casename + '-radiomics.csv'))
def __init__(self, feature_setting_file): with open(feature_setting_file) as f: content = f.readlines() content = [x.strip() for x in content] settings = {} settings['binWidth'] = 25 settings[ 'resampledPixelSpacing'] = None # [3,3,3] is an example for defining resampling (voxels with size 3x3x3mm) settings['interpolator'] = sitk.sitkBSpline self.extractor = featureextractor.RadiomicsFeatureExtractor(**settings) self.extractor.disableAllFeatures() self.extractor.enableFeaturesByName(firstorder=['Mean', 'Skewness']) feature_dict = {} for line in content: feature_type, feature_name = line.split(':') if feature_type in feature_dict: feature_dict[feature_type].append(feature_name) else: feature_dict[feature_type] = [feature_name] for feature_type, feature_name_list in feature_dict.items(): if feature_type == 'firstorder': self.extractor.enableFeaturesByName( firstorder=feature_name_list) if feature_type == 'glcm': self.extractor.enableFeaturesByName(glcm=feature_name_list) if feature_type == 'gldm': self.extractor.enableFeaturesByName(gldm=feature_name_list) if feature_type == 'shape': self.extractor.enableFeaturesByName(shape=feature_name_list) if feature_type == 'glrlm': self.extractor.enableFeaturesByName(glrlm=feature_name_list) if feature_type == 'glszm': self.extractor.enableFeaturesByName(glszm=feature_name_list) if feature_type == 'ngtdm': self.extractor.enableFeaturesByName(ngtdm=feature_name_list) self.generate_feature_name_list()
def T2(): ori_path = entry2.get() lab_path = entry5.get() para_path = 'param.yaml' extractor = FEE.RadiomicsFeatureExtractor(para_path) result = extractor.execute(ori_path, lab_path) T2WI_value = ( (-0.0461) * (result['original_glszm_SmallAreaHighGrayLevelEmphasis'] - 858.855129370635) / 523.622693874222 + (0.0721) * (result['log-sigma-3-0-mm-3D_firstorder_Mean'] + 7.10987898428323) / 9.86574336008581 + (0.0143) * (result['wavelet-LHL_firstorder_Median'] + 0.497480301566474) / 6.70861813994384 + (0.0026) * (result['wavelet-HLL_firstorder_Median'] + 0.50384535450867) / 6.64617085861184 + (-0.0288) * (result['wavelet-HLL_firstorder_Skewness'] + 0.433378035999999) / 0.857937526164875 + (-0.0650) * (result['wavelet-HLL_glcm_Correlation'] - 0.0799560479942196) / 0.0842701277455332 + (-0.0293) * (result['wavelet-LLL_firstorder_10Percentile'] - 212.791719080578) / 113.352771138532) return T2WI_value
def extract_radiomic_feature(center_img_path, label_img_path): if isinstance(center_img_path, str): center_img_2d = sitk.ReadImage(center_img_path) label_img_2d = sitk.ReadImage(label_img_path) img = sitk.JoinSeries(center_img_2d) lbl = sitk.JoinSeries(label_img_2d) params = 'model/params.yaml' extractor = featureextractor.RadiomicsFeatureExtractor(params) extractor.enableAllImageTypes() features = get_feature_list('model/selected.txt') result = extractor.execute(img, lbl) features_list = [] for f in features: features_list.append(result.get(f)) ''' for i, j in zip(features, features_list): print(i, j) ''' return features_list
def get_features(outputFilePath, binwidth): settingPath = 'E:/hypertension/hypertension_code/segment_feature/setting.yaml' imagePath = 'E:/hypertension/3.kidneynrrd(new_data)/process_data/kidney_data/' maskPath = 'E:/hypertension/3.kidneynrrd(new_data)/process_data/fat_predict/' # imageNames = [name for name in os.listdir(imagePath) if name.split('.')[1] == 'mhd'] # maskNames = [name.split('.')[0] + '_roi.mhd' for name in imageNames] imageNames = os.listdir(imagePath) maskNames = imageNames # Initialize feature extractor extractor = featureextractor.RadiomicsFeatureExtractor(settingPath, binWidth=binwidth) headers = None for i in range(len(imageNames)): featureVector = collections.OrderedDict() featureVector['Image'] = imageNames[i].split('_')[4] imageFilePath = imagePath + imageNames[i] maskFilePath = maskPath + maskNames[i] # Calculating features featureVector.update(extractor.execute(imageFilePath, maskFilePath)) with open(outputFilePath, 'a') as outputFile: writer = csv.writer(outputFile, lineterminator='\n') if headers is None: headers = list(featureVector.keys()) writer.writerow(headers) row = [] for h in headers: row.append(featureVector.get(h, "N/A")) writer.writerow(row)