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
