def main(): args = parser.parse_args() # Initialize Logging logLevel = getattr(logging, args.logging_level) rLogger = radiomics.logger # Set up optional logging to file if args.log_file is not None: rLogger.setLevel(logLevel) handler = logging.StreamHandler(args.log_file) handler.setFormatter( logging.Formatter("%(levelname)s:%(name)s: %(message)s")) rLogger.addHandler(handler) # Set verbosity of output (stderr) verboseLevel = (6 - args.verbosity) * 10 # convert to python logging level radiomics.setVerbosity(verboseLevel) # Initialize logging for script log messages logger = rLogger.getChild('script') # Initialize extractor try: if args.param is not None: extractor = featureextractor.RadiomicsFeaturesExtractor( args.param[0]) else: extractor = featureextractor.RadiomicsFeaturesExtractor() logger.info( 'Extracting features with kwarg settings: %s\n\tImage: %s\n\tMask: %s', str(extractor.kwargs), os.path.abspath(args.image), os.path.abspath(args.mask)) featureVector = collections.OrderedDict() featureVector['image'] = os.path.basename(args.image) featureVector['mask'] = os.path.basename(args.mask) featureVector.update( extractor.execute(args.image, args.mask, args.label)) if args.format == 'csv': writer = csv.writer(args.out, lineterminator='\n') writer.writerow(list(featureVector.keys())) writer.writerow(list(featureVector.values())) elif args.format == 'json': json.dump(featureVector, args.out) args.out.write('\n') else: for k, v in six.iteritems(featureVector): args.out.write('%s: %s\n' % (k, v)) except Exception: logger.error('FEATURE EXTRACTION FAILED:\n%s', traceback.format_exc()) args.out.close() if args.log_file is not None: args.log_file.close()
def main(): args = parser.parse_args() # Initialize Logging logLevel = eval('logging.' + args.logging_level) rLogger = logging.getLogger('radiomics') rLogger.handlers = [] rLogger.setLevel(logLevel) logger = logging.getLogger() logger.setLevel(logLevel) handler = logging.StreamHandler(args.log_file) handler.setLevel(logLevel) handler.setFormatter( logging.Formatter("%(levelname)s:%(name)s: %(message)s")) logger.addHandler(handler) # Initialize extractor try: if args.param is not None: extractor = featureextractor.RadiomicsFeaturesExtractor( args.param[0]) else: extractor = featureextractor.RadiomicsFeaturesExtractor() logging.info( 'Extracting features with kwarg settings: %s\n\tImage:%s\n\tMask:%s', str(extractor.kwargs), os.path.abspath(args.image), os.path.abspath(args.mask)) featureVector = collections.OrderedDict() featureVector['image'] = os.path.basename(args.image) featureVector['mask'] = os.path.basename(args.mask) featureVector.update( extractor.execute(args.image, args.mask, args.label)) if args.format == 'csv': writer = csv.writer(args.out, lineterminator='\n') writer.writerow(featureVector.keys()) writer.writerow(featureVector.values()) elif args.format == 'json': json.dump(featureVector, args.out) args.out.write('\n') else: for k, v in six.iteritems(featureVector): args.out.write('%s: %s\n' % (k, v)) except Exception: logging.error('FEATURE EXTRACTION FAILED:\n%s', traceback.format_exc()) args.out.close() args.log_file.close()
def calculateFeatures(self, grayscaleImage, labelImage, featureClasses, **kwargs): # type: (object, object, object, object) -> object """ Calculate a single feature on the input MRML volume nodes """ self.logger.debug('Calculating features for %s', featureClasses) self.logger.debug('Instantiating the extractor') extractor = featureextractor.RadiomicsFeaturesExtractor(**kwargs) extractor.disableAllFeatures() for feature in featureClasses: extractor.enableFeatureClassByName(feature) self.logger.debug('Starting feature calculation') featureValues = {} try: featureValues = extractor.execute(grayscaleImage, labelImage) except: self.logger.error('pyradiomics feature extractor failed') self.logger.debug('Features calculated') return featureValues
def calculateFeatures(self, grayscaleImage, labelImage, featureClasses, settings, enabledImageTypes): # type: (Simple ITK image object, Simple ITK image object, list, dict, dict) -> dict """ Calculate a single feature on the input MRML volume nodes """ self.logger.debug('Calculating features for %s', featureClasses) self.logger.debug('Instantiating the extractor') extractor = featureextractor.RadiomicsFeaturesExtractor(**settings) extractor.disableAllFeatures() for feature in featureClasses: extractor.enableFeatureClassByName(feature) extractor.disableAllImageTypes() for imageType in enabledImageTypes: extractor.enableImageTypeByName(imageType, customArgs=enabledImageTypes[imageType]) self.logger.debug('Starting feature calculation') featureValues = {} try: featureValues = extractor.execute(grayscaleImage, labelImage) except: self.logger.error('pyradiomics feature extractor failed') traceback.print_exc() self.logger.debug('Features calculated') return featureValues
def _extract_features(self, image, mask): print('CalculateRadiomicsFeatures._extract_features()') extractor = featureextractor.RadiomicsFeaturesExtractor( **self.get_param('settings')) extractor.enableAllFeatures() v = extractor.execute(image, mask) return v
def get_GLRLM_features(image, mask): mask = mask.astype(int) image = sitk.GetImageFromArray(image) mask = sitk.GetImageFromArray(mask) kwargs = { 'binWidth': 25, 'interpolator': sitk.sitkBSpline, 'resampledPixelSpacing': None, 'verbose': True } # Initialize wrapperClass to generate signature extractor = featureextractor.RadiomicsFeaturesExtractor(**kwargs) extractor.disableAllFeatures() extractor.enableFeatureClassByName('glrlm') featureVector = extractor.execute(image, mask) # Assign features to corresponding groups GLRLM_labels_temp = list() GLRLM_features = list() for featureName in featureVector.keys(): # Skip the "general" features if 'glrlm' in featureName: GLRLM_labels_temp.append(featureName) GLRLM_features.append(featureVector[featureName]) # Replace part of label to indicate a texture feature GLRLM_labels = list() for l in GLRLM_labels_temp: l = l.replace('original_glrlm', 'tf_GLRLM') GLRLM_labels.append(l) return GLRLM_features, GLRLM_labels
def feature_extract( image_origin, image_mask, features=['firstorder', 'glcm', 'glszm', 'glrlm', 'ngtdm', 'shape']): ''' :param image_origin: image_array (numpy array) :param image_mask: mask_array (numpy array) :subject: subject name :return: whole features, featureVector, make csv_file ''' image = Numpy2Itk(image_origin) mask = Numpy2Itk(image_mask) settings = {} settings['binwidth'] = 25 settings['resampledPixelSpacing'] = None settings['interpolator'] = 'sitkBSpline' settings['verbose'] = True extractor = featureextractor.RadiomicsFeaturesExtractor(**settings) extractor.settings['enableCExtensions'] = True for feature in features: extractor.enableFeatureClassByName(feature.lower()) featureVector = extractor.execute(image, mask) cols = [] feats = [] for feature in features: for featureName in featureVector.keys(): if feature in featureName: cols.append(featureName) feats.append(featureVector[featureName]) return feats, cols
def get_extractor(self): # Initialize extractor extractor = featureextractor.RadiomicsFeaturesExtractor() extractor.enableAllImageTypes() extractor.enableAllFeatures() return extractor
def run_phantom(): global TYPES ibsiLogger.info('################################### Extracting Phantom #############################') extractor = featureextractor.RadiomicsFeaturesExtractor() image = sitk.ReadImage(os.path.join('data', 'digital_phantom', 'Phantom.nrrd')) mask = sitk.ReadImage(os.path.join('data', 'digital_phantom', 'Phantom-label.nrrd')) result_series = pd.Series() extraction_mode = ('2D', '3D') for e in extraction_mode: ibsiLogger.info('######################### MODE %s ####################' % e) for t in TYPES: ibsiLogger.info('######################### TYPE %s ####################' % t) params = os.path.join('configuration', 'Phantom%s.yml' % t) if not os.path.isfile(params): continue extractor.loadParams(params) extractor.addProvenance(provenance_on=(t == '')) extractor.settings['force2D'] = e == '2D' fv = pd.Series(extractor.execute(image, mask)) if t != '': fv = fv.add_prefix(t[1:] + '_') if extractor.settings.get('force2D', False): fv = fv.add_prefix('2D_') else: fv = fv.add_prefix('3D_') result_series = result_series.append(fv) result_series.name = 'phantom' #result_series.to_csv('resCase%d.csv' % case_idx) # Uncomment to enable saving intermediate results return result_series
def featureExtract(var): params_path = os.path.abspath('Params.yaml') extractor = featureextractor.RadiomicsFeaturesExtractor(params_path) results = pandas.DataFrame() try: image_path = var.im_path image_name = var.im_path.split('\\') image_name = image_name[-1] print(image_name) im = cv2.imread(image_path) im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) im = cv2.resize(im, (256, 256)) mask = np.ones([256, 256]) im = sitk.GetImageFromArray([np.asarray(im)]) mask = sitk.GetImageFromArray([np.asarray(mask)]) sitk.WriteImage(im, source_path) sitk.WriteImage(mask, mask_path) print('fdssssssssssssssssssssssssssssssssss') featureVector = pandas.Series(extractor.execute( source_path, mask_path)) featureVector.name = image_name results = results.join(featureVector, how='outer') results = results.T drop_dp = results.filter(regex=('diagnostics.*')) results = results.drop(drop_dp.columns, axis=1) results.to_csv(output_path, encoding='utf_8_sig') except Exception as e: logging.exception(e)
def get_GLSZM_features(image, mask): mask = mask.astype(int) image = sitk.GetImageFromArray(image) mask = sitk.GetImageFromArray(mask) kwargs = { 'binWidth': 25, 'interpolator': sitk.sitkBSpline, 'resampledPixelSpacing': None, 'verbose': True } # Initialize wrapperClass to generate signature extractor = featureextractor.RadiomicsFeaturesExtractor(**kwargs) extractor.disableAllFeatures() extractor.enableFeatureClassByName('glszm') featureVector = extractor.execute(image, mask) # Assign features to corresponding groups GLSZM_labels = list() GLSZM_features = list() for featureName in featureVector.keys(): # Skip the "general" features if 'glszm' in featureName: GLSZM_labels.append(featureName) GLSZM_features.append(featureVector[featureName]) features = dict(zip(GLSZM_labels, GLSZM_features)) return features
def getFeatures(imageName, maskName, imageITK, maskITK, y_label, paramPath): # extract features using pyradiomic. extractor = featureextractor.RadiomicsFeaturesExtractor(paramPath) featureVector = extractor.execute(imageITK, maskITK) new_row = {} for featureName in featureVector.keys( ): # Note that featureVectors is a 'disordered dictionary' # print('Computed %s: %s' % (featureName, featureVector[featureName])) # print(featureVector[featureName]) if ('firstorder' in featureName) or ('glszm' in featureName) or \ ('glcm' in featureName) or ('glrlm' in featureName) or \ ('gldm' in featureName) or ('shape' in featureName): new_row.update({featureName: featureVector[featureName]}) lst = sorted(new_row.items()) # Ordering the new_row dictionary. # Adding some columns lst.insert(0, ('diagnosis', y_label)) lst.insert(0, ('mask_filename', maskName)) lst.insert(0, ('image_filename', imageName)) od = OrderedDict(lst) return (od)
def run_case(case_idx, image, mask): global TYPES, GRAY_VALUE_ROUNDING, ibsiLogger ibsiLogger.info('################################### Extracting Case %d #############################' % case_idx) extractor = featureextractor.RadiomicsFeaturesExtractor() result_series = pd.Series() for t in TYPES: ibsiLogger.info('######################### TYPE %s ####################' % t) params = os.path.join('configuration', 'case%d%s.yml' % (case_idx, t)) if not os.path.isfile(params): continue extractor.loadParams(params) if GRAY_VALUE_ROUNDING: extractor.settings['grayValuePrecision'] = 0 # round to nearest integer when using IBSI resampling extractor.addProvenance(provenance_on=(t == '')) fv = pd.Series(extractor.execute(image, mask)) if t != '': fv = fv.add_prefix(t[1:] + '_') if extractor.settings.get('force2D', False): fv = fv.add_prefix('2D_') else: fv = fv.add_prefix('3D_') result_series = result_series.append(fv) result_series.name = case_idx return result_series
def GetFeature(imageName, maskName, para_path): # print("originl path: " + ori_path) # print("label path: " + lab_path) # print("parameter path: " + para_path) 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() # 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 # Set up the handler to 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) # 使用配置文件初始化特征抽取器 extractor = FEE.RadiomicsFeaturesExtractor(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(imageName, maskName) #抽取特征 # print ("Result type:", type(result)) # result is returned in a Python ordered dictionary # print ("Calculated features") # for key, value in result.items(): #输出特征 # print ("\t", key, ":", value) return result
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.RadiomicsFeaturesExtractor(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 do_it(i, x, y, z, flattened_index, winSize, paramPath, volume, label_value, image_filename, mask_filename, caseID, lessionID, image_metadata, mask_metadata): #print("Process {} working in index: {}".format(os.getpid(), flattened_index)) mask_trick = np.ones((winSize, winSize, winSize), dtype=np.int) maskITK = sitk.GetImageFromArray(mask_trick) maskITK.origin = image_metadata.origin maskITK.spacing = image_metadata.spacing maskITK.direction = image_metadata.direction extractor = featureextractor.RadiomicsFeaturesExtractor(paramPath) imageITK = sitk.GetImageFromArray(volume) imageITK.origin = mask_metadata.origin imageITK.spacing = mask_metadata.spacing imageITK.direction = mask_metadata.direction new_row = {} featureVector = extractor.execute(imageITK, maskITK) # allways is used the same mask # print("Result type: {} and length: {}".format(type(featureVector), len(featureVector))) # result is returned in a Python ordered dictionary) # print('') # print('Calculated features') for featureName in featureVector.keys( ): # Note that featureVectors is a 'disordered dictionary' # print('Computed %s: %s' % (featureName, featureVector[featureName])) # print(featureVector[featureName]) if ('firstorder' in featureName) or ('glszm' in featureName) or \ ('glcm' in featureName) or ('glrlm' in featureName) or \ ('gldm' in featureName): new_row.update({featureName: featureVector[featureName]}) lst = sorted(new_row.items()) # Ordering the new_row dictionary # Adding some columns and values at the front of the list # label_value = mask[z, x, y] lst.insert(0, ('label', label_value)) lst.insert(0, ('axisZ', z)) lst.insert(0, ('axisY', y)) lst.insert(0, ('axisX', x)) # flattened_index = np.ravel_multi_index([[z], [y], [x]], (3, 3, 3), order='F') # np.ravel_multi_index([[2],[1],[0]],rw.shape[:3]) # [flattened_index] = np.ravel_multi_index([[x], [y], [z]], (max_x, max_y, max_z)) # order='C' lst.insert(0, ('flattened_index', int(flattened_index))) lst.insert(0, ('lessionID', lessionID)) lst.insert(0, ('caseID', caseID)) lst.insert(0, ('mask_filename', mask_filename)) lst.insert(0, ('image_filename', image_filename)) od = OrderedDict(lst) # for name in od.keys(): # print('Computed %s: %s' % (name, od[name])) #print("Process {} done processing index: {}".format(os.getpid(), flattened_index)) return (i, od)
def instantiate_extractor(): print('Instantiating extractor...') extractor = featureextractor.RadiomicsFeaturesExtractor(normalize=True, correctMask=True, resampledPixelSpacing=[0.5,0.5,0.5]) extractor.addProvenance() extractor.enableAllImageTypes() return extractor
def volume_calc(imageName): #Load MRI image data from ITK json_output = "JSON-Output" if (os.path.isdir(json_output) == False): os.mkdir(json_output) img = sitk.ReadImage(imageName) file_name = imageName.split("/")[-1] print(file_name) #casting the image so that the pixel dimesions all match with each other img_mask = sitk.Cast(img, sitk.sitkUInt8) img = sitk.Cast(img, sitk.sitkFloat32) corrector = sitk.N4BiasFieldCorrectionImageFilter() #corrector is used so that there is an equation of the dimensions img_c = corrector.Execute(img, img_mask) #img_c = corrector.Execute(img) #params = os.path.join(dataDir, "bin", "Params.yaml") #specify the parameters for the program to execute(Pyradiomics) params = "Params.yaml" #Setting up model to extract features extractor = featureextractor.RadiomicsFeaturesExtractor(params) ''' #check configuration print('Extraction parameters:\n\t', extractor.settings) print('Enabled filters:\n\t', extractor._enabledImagetypes) print('Enabled features:\n\t', extractor._enabledFeatures) ''' #Hippocampus ROI hippocampus = extractor.execute(img, img_mask, label=53) save(json_output, hippocampus, "hippocampus", file_name) #Thalamus thalamus = extractor.execute(img, img_mask, label=10) save(json_output, thalamus, "thalamus", file_name) ''' #Sample output print('Result type:', type(thalamus)) # result is returned in a Python ordered dictionary) print('') print('Calculated features for Label 6') for key, value in thalamus.items(): print('\t', key, ':', value) ''' #Caudate caudate = extractor.execute(img, img_mask, label=11) save(json_output, caudate, "caudate", file_name) #Putamen putamen = extractor.execute(img, img_mask, label=12) save(json_output, putamen, "putamen", file_name) #Pallidum pallidum = extractor.execute(img, img_mask, label=13) save(json_output, pallidum, "pallidum", file_name)
def build_extractor(self, paramPath): # Instantiate the extractor with the parameters in the file paramPath. self.extractor = featureextractor.RadiomicsFeaturesExtractor(paramPath) print("Using configuration file to parameters: {}".format(paramPath)) print("Extraction parameters: {}".format( OrderedDict(sorted(self.extractor.settings.items())))) print('Enabled filters:\n\t', OrderedDict(sorted(self.extractor._enabledImagetypes.items()))) print('Enabled features:\n\t', OrderedDict(sorted(self.extractor._enabledFeatures.items())))
def get_all_feature(data_dir, save_dir): edema_file_names = glob.glob(data_dir + '/*/*.npy') # 获取ROI数据 edema_file_names.sort() print('number of data:', len(edema_file_names)) all_roi_data = {} edema_file_names.sort() params = './libs/rlm_params.yaml' extractor = featureextractor.RadiomicsFeaturesExtractor(params) for i, file in enumerate(edema_file_names): print file, '--------------------------', i # file = '/all/DATA_PROCEING/preprocessed/new_roi/edema/1/WU_XU_BIN-15.npy' brain_type = file.split('/')[-3] label = file.split('/')[-2] name = file.split('/')[-1] person, idx = name.split('-') idx = int(idx.replace('.npy', '')) # dcm从1开始计数 roi_data = center_crop(np.load(file)) print np.max(roi_data), np.min(roi_data) dcm_data = (dicom.read_file(origin_data_dir + label + '/{}'.format(brain_type) + person + '/' + str(idx) + '.dcm')).pixel_array # 水肿 # roi_data = normalize(roi_data) # dcm_data = normalize(dcm_data) # roi_data = standardrize(roi_data) # dcm_data = standardrize(dcm_data) # print np.max(normalized_dcm), np.min(normalized_dcm) # plt.subplot(121) # plt.imshow(dcm_data, cmap='gray') # plt.subplot(122) # plt.imshow(roi_data, cmap='gray') # plt.show() rlm = comput_rlm(roi_data, dcm_data, extractor) # 16 glcm = comput_glcm(roi_data) # 44 hog = comput_hog(roi_data) # 36 haralick = comput_haralick(roi_data) # 13 shape = comput_shape(roi_data) # 7 # # feature = np.hstack([glcm, hog, haralick, shape]) # 顺序一定不能乱 feature = np.hstack([hog, haralick, shape, glcm, rlm]) # 顺序一定不能乱 # feature = rlm # if feature == None: # continue print feature.shape roi_data[roi_data != 0] = 1 area = np.sum(roi_data) print area np.save(save_dir + '/' + label + '/' + name + '.npy', [feature, area]) # break return all_roi_data
def AllFeatures(image, mask): # Define settings for signature calculation # These are currently set equal to the respective default values kwargs = {} kwargs['binWidth'] = 25 kwargs['resampledPixelSpacing'] = None # [3,3,3] is an example for defining resampling (voxels with size 3x3x3mm) kwargs['interpolator'] = sitk.sitkBSpline kwargs['verbose'] = True # Initialize wrapperClass to generate signature extractor = featureextractor.RadiomicsFeaturesExtractor(**kwargs) # By default, only original is enabled. Optionally enable some filters: # extractor.enableInputImages(Original={}, LoG={}, Wavelet={}) # Disable all classes except firstorder extractor.enableAllFeatures() # Enable all features in firstorder # extractor.enableFeatureClassByName('firstorder') # Only enable mean and skewness in firstorder # extractor.enableFeaturesByName(firstorder=['Mean', 'Skewness']) # Enable writing out the log using radiomics logger radiomics.debug() # Switch on radiomics logging from level=DEBUG (default level=WARNING) # Prevent radiomics logger from printing out log entries with level < WARNING to the console logger = logging.getLogger('radiomics') logger.handlers[0].setLevel(logging.WARNING) logger.propagate = False # Do not pass log messages on to root logger # 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) print("Active features:") for cls, features in extractor.enabledFeatures.iteritems(): if len(features) == 0: features = extractor.getFeatureNames(cls) for f in features: print(f) print(eval('extractor.featureClasses["%s"].get%sFeatureValue.__doc__' % (cls, f))) print("Calculating features") featureVector = extractor.execute(image, mask) for featureName in featureVector.keys(): print("Computed %s: %s" % (featureName, featureVector[featureName])) return featureVector
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.RadiomicsFeaturesExtractor(radiomics_parameter_file) self.error_list = [] self.logger = logging.getLogger(__name__) self.__has_label = has_label self.__is_ignore_tolerence = ignore_tolerence self.__is_ignore_diagnostic = ignore_diagnostic self.error_list = []
def __init__(self, radiomics_parameter_file, config_file, modality_name_list): self.feature_values = [] self.case_list = [] self.feature_name_list = [] self.config_dict = dict() self.modality_name_list = modality_name_list self.logger = logging.getLogger(__name__) try: self.extractor = featureextractor.RadiomicsFeaturesExtractor(radiomics_parameter_file) self.LoadFileConfig(config_file) except: traceback.print_exc() print('Check the config file path.')
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.RadiomicsFeaturesExtractor(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) # tqdmProgressbar() # clickProgressbar() print("Active features:") for cls, features in six.iteritems(extractor.enabledFeatures): # if len(features) == 0: if not features: features = extractor.getFeatureNames(cls) for f in features: print(f) print( getattr(extractor.featureClasses[cls], 'get%sFeatureValue' % f).__doc__) print("Calculating features") featureVector = extractor.execute(imageName, maskName) for featureName in featureVector.keys(): print("Computed %s: %s" % (featureName, featureVector[featureName])) return featureVector
def Extract_Features(image, mask, params_path): paramsFile = os.path.abspath(params_path) extractor = featureextractor.RadiomicsFeaturesExtractor(paramsFile) result = extractor.execute(image, mask) general_info = { 'diagnostics_Configuration_EnabledImageTypes', 'diagnostics_Configuration_Settings', 'diagnostics_Image-interpolated_Maximum', 'diagnostics_Image-interpolated_Mean', 'diagnostics_Image-interpolated_Minimum', 'diagnostics_Image-interpolated_Size', 'diagnostics_Image-interpolated_Spacing', 'diagnostics_Image-original_Hash', 'diagnostics_Image-original_Maximum', 'diagnostics_Image-original_Mean', 'diagnostics_Image-original_Minimum', 'diagnostics_Image-original_Size', 'diagnostics_Image-original_Spacing', 'diagnostics_Mask-interpolated_BoundingBox', 'diagnostics_Mask-interpolated_CenterOfMass', 'diagnostics_Mask-interpolated_CenterOfMassIndex', 'diagnostics_Mask-interpolated_Maximum', 'diagnostics_Mask-interpolated_Mean', 'diagnostics_Mask-interpolated_Minimum', 'diagnostics_Mask-interpolated_Size', 'diagnostics_Mask-interpolated_Spacing', 'diagnostics_Mask-interpolated_VolumeNum', 'diagnostics_Mask-interpolated_VoxelNum', 'diagnostics_Mask-original_BoundingBox', 'diagnostics_Mask-original_CenterOfMass', 'diagnostics_Mask-original_CenterOfMassIndex', 'diagnostics_Mask-original_Hash', 'diagnostics_Mask-original_Size', 'diagnostics_Mask-original_Spacing', 'diagnostics_Mask-original_VolumeNum', 'diagnostics_Mask-original_VoxelNum', 'diagnostics_Versions_Numpy', 'diagnostics_Versions_PyRadiomics', 'diagnostics_Versions_PyWavelet', 'diagnostics_Versions_Python', 'diagnostics_Versions_SimpleITK', 'diagnostics_Image-original_Dimensionality' } features = dict((key, value) for key, value in result.items() if key not in general_info) feature_info = dict( (key, value) for key, value in result.items() if key in general_info) return features, feature_info
def get_NGTDM_features(image, mask): mask = mask.astype(int) image = sitk.GetImageFromArray(image) mask = sitk.GetImageFromArray(mask) kwargs = { 'binWidth': 25, 'interpolator': sitk.sitkBSpline, 'resampledPixelSpacing': None, 'verbose': True } # Initialize wrapperClass to generate signature extractor = featureextractor.RadiomicsFeaturesExtractor(**kwargs) extractor.disableAllFeatures() extractor.enableFeatureClassByName('ngtdm') extractor.settings['distances'] = [1] featureVector = extractor.execute(image, mask) # Assign features to corresponding groups NGTDM_labels_temp = list() NGTDM_features = list() for featureName in featureVector.keys(): # Skip the "general" features if 'ngtdm' in featureName: NGTDM_labels_temp.append(featureName) NGTDM_features.append(featureVector[featureName]) # Replace part of label to indicate a texture feature NGTDM_labels = list() for l in NGTDM_labels_temp: l = l.replace('original_ngtdm', 'tf_NGTDM') NGTDM_labels.append(l) #Replace every NaN by zero for i in range(len(NGTDM_features)): if np.isnan(NGTDM_features[i]): NGTDM_features[i] = 0 print("NaN found, replaced with zero.") return NGTDM_features, NGTDM_labels
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.RadiomicsFeaturesExtractor( **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 runWithParameterFile(self, imageNode, labelNode, segmentationNode, parameterFilePath): """ Run the actual algorithm using the provided customization file and provided image and region of interest(s) (ROIs) :param imageNode: Slicer Volume node representing the image from which features should be extracted :param labelNode: Slicer Labelmap node containing the ROIs as integer encoded volume (voxel value indicates ROI id) :param segmentationNode: Slicer segmentation node containing the segments of the ROIs (will be converted to binary label maps) :param parameterFilePath: String file path pointing to the parameter file used to customize the extraction :return: Dictionary containing the extracted features for each ROI """ self.logger.info('Feature extraction started') self.logger.debug('Instantiating the extractor') # Instantiate the extractor with the specified customization file. If this file is invalid in any way, this call # will raise an error. extractor = featureextractor.RadiomicsFeaturesExtractor( parameterFilePath) return self.calculateFeatures(imageNode, labelNode, segmentationNode, extractor)
def run(self, imageNode, labelNode, segmentationNode, featureClasses, settings, enabledImageTypes): """ Run the actual algorithm """ self.logger.info('Feature extraction started') self.logger.debug('Instantiating the extractor') extractor = featureextractor.RadiomicsFeaturesExtractor(**settings) self.logger.debug('Setting the enabled feature classes') extractor.disableAllFeatures() for feature in featureClasses: extractor.enableFeatureClassByName(feature) self.logger.debug('Setting the enabled image types') extractor.disableAllImageTypes() for imageType in enabledImageTypes: extractor.enableImageTypeByName( imageType, customArgs=enabledImageTypes[imageType]) return self.calculateFeatures(imageNode, labelNode, segmentationNode, extractor)
def generateExtractor(spacing, sigma, quanAlgo, quanParam): settings = {} settings['resampledPixelSpacing'] = [spacing, spacing, spacing] settings['interpolator'] = sitk.sitkBSpline settings['enableCExtensions'] = True settings['normalize'] = True settings['normalizeScale'] = 1 settings['sigma'] = sigma if quanAlgo == 'binWidth': settings['binWidth'] = quanParam elif quanAlgo == 'binCount': settings['binCount'] = quanParam else: sys.exit('quanAlgo error.') extractor = featureextractor.RadiomicsFeaturesExtractor(**settings) extractor.disableAllImageTypes() extractor.enableImageTypeByName('LoG') extractor.enableImageTypeByName('Wavelet') extractor.enableImageTypeByName('Square') extractor.enableImageTypeByName('SquareRoot') extractor.enableImageTypeByName('Logarithm') extractor.enableImageTypeByName('Exponential') extractor.enableAllFeatures() return extractor