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)
