def LoadClinicalRef(self):
dlg = QFileDialog()
file_name, _ = dlg.getOpenFileName(self,
'Open SCV file',
filter="csv files (*.csv)")
if file_name:
try:
self.__clinical_ref = pd.read_csv(file_name, index_col=0)
if list(self.__clinical_ref.index
) != self.data_container.GetCaseName():
QMessageBox.information(
self, 'Error',
'The index of clinical features is not consistent to the data'
)
return None
self.loadClinicRef.setEnabled(False)
self.clearClinicRef.setEnabled(True)
except OSError as reason:
eclog(self._filename).GetLogger().error(
'Load Clinical Ref Error: {}'.format(reason))
QMessageBox.information(self, 'Error',
'Can not Open the Files')
except ValueError:
eclog(self._filename).GetLogger().error(
'OpenCSV Error: {}'.format(file_name))
QMessageBox.information(self, 'Error',
'The selected data file mismatch.')
return None
def GenerateDescription(self):
if (self.comboNormalizer.count() == 0) or \
(self.comboDimensionReduction.count() == 0) or \
(self.comboFeatureSelector.count() == 0) or \
(self.comboClassifier.count() == 0) or \
(self.spinBoxFeatureNumber.value() == 0):
return
dlg = QFileDialog()
dlg.setFileMode(QFileDialog.DirectoryOnly)
dlg.setOption(QFileDialog.ShowDirsOnly)
if dlg.exec_():
store_folder = dlg.selectedFiles()[0]
roc_path = os.path.join(store_folder, 'ROC.jpg')
self.canvasROC.getFigure().savefig(roc_path, dpi=300)
report = Description()
try:
pipeline_name = self._fae.GetStoreName(
self.comboNormalizer.currentText(),
self.comboDimensionReduction.currentText(),
self.comboFeatureSelector.currentText(),
str(self.spinBoxFeatureNumber.value()),
self.comboClassifier.currentText())
report.Run(pipeline_name, self._root_folder, store_folder)
os.system("explorer.exe {:s}".format(
os.path.normpath(store_folder)))
except Exception as ex:
QMessageBox.about(self, 'Description Generate Error: ',
ex.__str__())
print(eclog(self._filename))
eclog(self._filename).GetLogger().error(
'Description Generate Error: ' + ex.__str__())
def __init__(self, parent=None):
self._root_folder = ''
self._fae = FeatureAnalysisPipelines()
self.sheet_dict = dict()
self.logger = eclog(os.path.split(__file__)[-1]).GetLogger()
self.__is_ui_ready = False
super(VisualizationConnection, self).__init__(parent)
self.setupUi(self)
self.buttonLoadResult.clicked.connect(self.LoadAll)
self.buttonClearResult.clicked.connect(self.ClearAll)
self.buttonSave.clicked.connect(self.Save)
self.buttonGenerateDescription.clicked.connect(self.GenerateDescription)
self.__plt_roc = self.canvasROC.getFigure().add_subplot(111)
self.__plt_plot = self.canvasPlot.getFigure().add_subplot(111)
self.__contribution = self.canvasFeature.getFigure().add_subplot(111)
# Update Sheet
self.tableClinicalStatistic.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.tableClinicalStatistic.setSelectionBehavior(QAbstractItemView.SelectRows)
self.comboSheet.currentIndexChanged.connect(self.UpdateSheet)
self.checkMaxFeatureNumber.stateChanged.connect(self.UpdateSheet)
# self.tableClinicalStatistic.doubleClicked.connect(self.ShowOneResult)
self.tableClinicalStatistic.itemSelectionChanged.connect(self.ShowOneResult)
# Update ROC canvas
self.comboNormalizer.currentIndexChanged.connect(self.UpdateROC)
self.comboDimensionReduction.currentIndexChanged.connect(self.UpdateROC)
self.comboFeatureSelector.currentIndexChanged.connect(self.UpdateROC)
self.comboClassifier.currentIndexChanged.connect(self.UpdateROC)
self.spinBoxFeatureNumber.valueChanged.connect(self.UpdateROC)
self.checkROCCVTrain.stateChanged.connect(self.UpdateROC)
self.checkROCCVValidation.stateChanged.connect(self.UpdateROC)
self.checkROCTrain.stateChanged.connect(self.UpdateROC)
self.checkROCTest.stateChanged.connect(self.UpdateROC)
# Update Plot canvas
self.comboPlotX.currentIndexChanged.connect(self.UpdatePlot)
self.comboPlotY.currentIndexChanged.connect(self.UpdatePlot)
self.comboPlotNormalizer.currentIndexChanged.connect(self.UpdatePlot)
self.comboPlotDimensionReduction.currentIndexChanged.connect(self.UpdatePlot)
self.comboPlotFeatureSelector.currentIndexChanged.connect(self.UpdatePlot)
self.comboPlotClassifier.currentIndexChanged.connect(self.UpdatePlot)
self.spinPlotFeatureNumber.valueChanged.connect(self.UpdatePlot)
self.checkPlotCVTrain.stateChanged.connect(self.UpdatePlot)
self.checkPlotCVValidation.stateChanged.connect(self.UpdatePlot)
self.checkPlotTrain.stateChanged.connect(self.UpdatePlot)
# self.checkPlotTest.stateChanged.connect(self.UpdatePlot)
# Update Contribution canvas
self.radioContributionFeatureSelector.toggled.connect(self.UpdateContribution)
self.radioContributionClassifier.toggled.connect(self.UpdateContribution)
self.comboContributionNormalizor.currentIndexChanged.connect(self.UpdateContribution)
self.comboContributionDimension.currentIndexChanged.connect(self.UpdateContribution)
self.comboContributionFeatureSelector.currentIndexChanged.connect(self.UpdateContribution)
self.comboContributionClassifier.currentIndexChanged.connect(self.UpdateContribution)
self.spinContributeFeatureNumber.valueChanged.connect(self.UpdateContribution)
def __init__(self, parent=None):
self.training_data_container = DataContainer()
self.testing_data_container = DataContainer()
self.fae = FeatureAnalysisPipelines()
self.logger = eclog(os.path.split(__file__)[-1]).GetLogger()
self.__process_normalizer_list = []
self.__process_dimension_reduction_list = []
self.__process_feature_selector_list = []
self.__process_feature_number_list = []
self.__process_classifier_list = []
super(ProcessConnection, self).__init__(parent)
self.setupUi(self)
self.buttonLoadTrainingData.clicked.connect(self.LoadTrainingData)
self.buttonLoadTestingData.clicked.connect(self.LoadTestingData)
self.checkNormalizeUnit.clicked.connect(self.UpdatePipelineText)
self.checkNormalizeZeroCenter.clicked.connect(self.UpdatePipelineText)
self.checkNormalizeUnitWithZeroCenter.clicked.connect(
self.UpdatePipelineText)
self.checkNormalizationAll.clicked.connect(self.SelectAllNormalization)
self.checkPCA.clicked.connect(self.UpdatePipelineText)
self.checkRemoveSimilarFeatures.clicked.connect(
self.UpdatePipelineText)
self.checkPreprocessAll.clicked.connect(self.SelectAllPreprocess)
self.spinBoxMinFeatureNumber.valueChanged.connect(
self.MinFeatureNumberChange)
self.spinBoxMaxFeatureNumber.valueChanged.connect(
self.MaxFeatureNumberChange)
self.checkANOVA.clicked.connect(self.UpdatePipelineText)
self.checkRFE.clicked.connect(self.UpdatePipelineText)
self.checkRelief.clicked.connect(self.UpdatePipelineText)
self.checkMRMR.clicked.connect(self.UpdatePipelineText)
self.checkFeatureSelectorAll.clicked.connect(
self.SelectAllFeatureSelector)
self.checkSVM.clicked.connect(self.UpdatePipelineText)
self.checkLDA.clicked.connect(self.UpdatePipelineText)
self.checkAE.clicked.connect(self.UpdatePipelineText)
self.checkRF.clicked.connect(self.UpdatePipelineText)
self.checkLogisticRegression.clicked.connect(self.UpdatePipelineText)
self.checkLRLasso.clicked.connect(self.UpdatePipelineText)
self.checkAdaboost.clicked.connect(self.UpdatePipelineText)
self.checkDecisionTree.clicked.connect(self.UpdatePipelineText)
self.checkNaiveBayes.clicked.connect(self.UpdatePipelineText)
self.checkGaussianProcess.clicked.connect(self.UpdatePipelineText)
self.checkClassifierAll.clicked.connect(self.SelectAllClassifier)
self.radio5folder.clicked.connect(self.UpdatePipelineText)
self.radio10Folder.clicked.connect(self.UpdatePipelineText)
self.radioLOO.clicked.connect(self.UpdatePipelineText)
self.buttonRun.clicked.connect(self.Run)
self.UpdatePipelineText()
self.SetStateButtonBeforeLoading(False)
def __init__(self, array=np.array([]), label=np.array([]), feature_name=[], case_name=[]):
self.__feature_name = feature_name
self.__case_name = case_name
self.__label = label
self._array = array
self.logger = eclog(os.path.split(__file__)[-1]).GetLogger()
if array.size != 0 and label.size != 0:
self.UpdateFrameByData()
else:
self.__df = None
def LoadTestingReferenceDataContainer(self):
dlg = QFileDialog()
file_name, _ = dlg.getOpenFileName(self,
'Open SCV file',
filter="csv files (*.csv)")
if file_name:
try:
self.__testing_ref_data_container.Load(file_name)
self.loadTestingReference.setEnabled(False)
self.clearTestingReference.setEnabled(True)
self.spinBoxSeparate.setEnabled(False)
except OSError as reason:
eclog(self._filename).GetLogger().error(
'Load Testing Ref Error: {}'.format(reason))
print('Error！' + str(reason))
except ValueError:
eclog(self._filename).GetLogger().error(
'Open CSV Error: {}'.format(file_name))
QMessageBox.information(self, 'Error',
'The selected data file mismatch.')
def LoadData(self):
dlg = QFileDialog()
file_name, _ = dlg.getOpenFileName(self,
'Open SCV file',
filter="csv files (*.csv)")
if file_name:
try:
if self.data_container.Load(file_name, is_update=True):
self.UpdateTable()
self.SetButtonsState(True)
except OSError as reason:
eclog(self._filename).GetLogger().error(
'Load CSV Error: {}'.format(reason))
QMessageBox.about(self, 'Load data Error', reason.__str__())
print('Error！' + str(reason))
except ValueError:
eclog(self._filename).GetLogger().error(
'Open CSV Error: {}'.format(file_name))
QMessageBox.information(self, 'Error',
'The selected data file mismatch.')
def __IterateCase(self,
root_folder,
key_name_list,
roi_key,
show_key_name_list,
store_path=''):
case_name_list = os.listdir(root_folder)
case_name_list.sort()
for case_name in case_name_list:
case_path = os.path.join(root_folder, case_name)
if not os.path.isdir(case_path):
continue
print(case_name)
try:
if self.feature_name_list != [] and self.feature_values != []:
feature_values = self.__GetFeatureValues(
case_path, key_name_list, show_key_name_list, roi_key)
if not self.__MergeCase(case_name, feature_values):
self.error_list.append(case_name)
else:
self.__InitialFeatureValues(case_path, key_name_list,
show_key_name_list, roi_key)
self.case_list.append(case_name)
except Exception as e:
content = 'In FeatureExtractor, {} extracted failed: '.format(
case_name)
eclog(self._file_name).LogError('{}{}'.format(content, str(e)))
self.error_list.append(case_name)
print('{} \n{}'.format(content, e.__str__()))
raise e
if store_path:
self.Save(store_path)
with open(os.path.join(store_path + '_error.csv'), 'w',
newline='') as csvfile:
writer = csv.writer(csvfile)
for error_case in self.error_list:
writer.writerow([error_case])
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 __init__(self, parent=None):
super(FeatureExactionConnection, self).__init__(parent)
self.setupUi(self)
self._root_folder = ''
self.logger = eclog(os.path.split(__file__)[-1]).GetLogger()
self.BrowseButton.clicked.connect(self.BrowseSourceFolder)
self.ExtractionButton.clicked.connect(self.BeginExtraction)
self.SelectButton.clicked.connect(self.BrowseOutputFile)
self.check_background_color = "background-color:rgba(255,0,0,64)"
self.raw_background_color = "background-color:rgba(255, 255, 255, 255)"
folder, _ = os.path.split(os.path.abspath(sys.argv[0]))
self.radiomics_config_path = folder + '/RadiomicsParams.yaml'
self.extraction = False
def __init__(self, parent=None):
super(PrepareConnection, self).__init__(parent)
self.setupUi(self)
self.data_container = DataContainer()
self.buttonLoad.clicked.connect(self.LoadData)
self.buttonRemove.clicked.connect(self.RemoveNonValidValue)
self.loadTestingReference.clicked.connect(
self.LoadTestingReferenceDataContainer)
self.clearTestingReference.clicked.connect(
self.ClearTestingReferenceDataContainer)
self.__testing_ref_data_container = DataContainer()
self.checkSeparate.clicked.connect(self.SetSeparateStatus)
self.spinBoxSeparate.setEnabled(False)
self.logger = eclog(os.path.split(__file__)[-1]).GetLogger()
self.loadTestingReference.setEnabled(False)
self.clearTestingReference.setEnabled(False)
self.buttonSave.clicked.connect(self.CheckAndSave)
def __init__(self, parent=None):
super(QWidget, self).__init__(parent)
self.ui = Ui_FeatureExtraction()
self._source_path = ''
self._cur_pattern_item = 0
self.logger = eclog(os.path.split(__file__)[-1]).GetLogger()
folder, _ = os.path.split(os.path.abspath(sys.argv[0]))
self.radiomics_config_path = folder + '/RadiomicsParams.yaml'
self.ui.setupUi(self)
self.ui.buttonBrowseSourceFolder.clicked.connect(self.BrowseSourceFolder)
self.ui.buttonBrowseRoiFile.clicked.connect(self.BrowseRoiFile)
self.ui.buttonAdd.clicked.connect(self.onButtonAddClicked)
self.ui.listWidgetImageFiles.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.listWidgetImageFiles.customContextMenuRequested[QtCore.QPoint].connect(
self.onListImageFilesContextMenuRequested)
self.ui.buttonBrowseFile.clicked.connect(self.BrowsePatternFile)
self.ui.buttonBrowseOutputFile.clicked.connect(self.BrowseOutputFile)
self.radiomics_params = RadiomicsParamsConfig(self.radiomics_config_path)
self.ui.buttonGo.clicked.connect(self.Go)
self.InitUi()
self.check_background_color = "background-color:rgba(255,0,0,64)"
self.raw_background_color = "background-color:rgba(25,35,45,255)"
return merge
def Merge(self):
if self.feature1.size == 0 or self.feature2.size ==0:
QMessageBox().about(self, '', 'Please Load Feature Matrix 1 and 2 both.')
return None
dlg = QFileDialog()
file_name, _ = dlg.getSaveFileName(self, 'Save CSV feature files', 'merge_features.csv',
filter="CSV files (*.csv)")
if not file_name:
return None
if self.ui.radioMergeTypeCases.isChecked():
merge_feature = self.MergeCases()
else:
merge_feature = self.MergeFeatures()
if merge_feature is None:
return None
merge_feature.to_csv(file_name)
if __name__ == '__main__':
import sys
app = QApplication(sys.argv)
main_frame = FeatureMergeForm(eclog())
main_frame.show()
sys.exit(app.exec_())
def __GetFeatureValues(self, case_folder, key_name_list,
show_key_name_list, roi_key):
feature_dict = {}
if isinstance(roi_key, str):
roi_key = [roi_key]
roi_key_path = '*'
for one_roi_key in roi_key:
roi_key_path += '{}*'.format(one_roi_key)
roi_candidate = glob.glob(os.path.join(case_folder, roi_key_path))
roi_candidate = [one for one in roi_candidate if 'nii' in one]
if len(roi_candidate) != 1:
eclog(
self._file_name).LogError('Check the ROI file path of case: ' +
case_folder)
return None
roi_file_path = roi_candidate[0]
quality_feature_path = os.path.join(case_folder, 'QualityFeature.csv')
if os.path.exists(quality_feature_path):
with open(quality_feature_path, 'r') as csvfile:
reader = csv.reader(csvfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
for row in reader:
feature_dict['Quality_' + row[0]] = row[1]
for sequence_key, show_key in zip(key_name_list, show_key_name_list):
if isinstance(sequence_key, str):
sequence_key = [sequence_key]
sequence_key_path = '*'
for one_sequence_key in sequence_key:
sequence_key_path += '{}*'.format(one_sequence_key)
sequence_candidate = glob.glob(
os.path.join(case_folder, sequence_key_path))
for one_roi_key in roi_key:
sequence_candidate = self._RemoveKeyFromPathList(
sequence_candidate, one_roi_key)
if len(sequence_candidate) != 1:
eclog(self._file_name).LogError(
'Check the data file path of case: ' + sequence_key_path)
return None
sequence_file_path = sequence_candidate[0]
feature_names_each_modality, feature_values_each_modality = \
self.__GetFeatureValuesEachModality(sequence_file_path, roi_file_path, show_key)
for feature_name, feature_value in zip(
feature_names_each_modality, feature_values_each_modality):
if feature_name in self.feature_name_list:
feature_dict[feature_name] = feature_value
else:
print('Check the feature name in the feature name list')
feature_dict = collections.OrderedDict(sorted(feature_dict.items()))
feature_values = list(feature_dict.values())
if self.__has_label:
label_value = 0
label_path = os.path.join(case_folder, 'label.csv')
if os.path.exists(label_path):
with open(label_path, 'r') as csvfile:
reader = csv.reader(csvfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
for row in reader:
label_value = row[0]
feature_values.insert(0, label_value)
else:
print('No label file!: ', label_path)
return feature_values
def CheckAndSave(self):
if self.data_container.IsEmpty():
QMessageBox.warning(self, "Warning", "There is no data",
QMessageBox.Ok)
elif not self.data_container.IsBinaryLabel():
QMessageBox.warning(self, "Warning", "There are not 2 Labels",
QMessageBox.Ok)
non_valid_number_index = self.data_container.FindInvalidLabelIndex(
)
old_edit_triggers = self.tableFeature.editTriggers()
self.tableFeature.setEditTriggers(QAbstractItemView.CurrentChanged)
self.tableFeature.setCurrentCell(non_valid_number_index, 0)
self.tableFeature.setEditTriggers(old_edit_triggers)
elif self.data_container.HasInvalidNumber():
QMessageBox.warning(self, "Warning", "There are nan items",
QMessageBox.Ok)
non_valid_number_index = self.data_container.FindInvalidNumberIndex(
)
old_edit_triggers = self.tableFeature.editTriggers()
self.tableFeature.setEditTriggers(QAbstractItemView.CurrentChanged)
self.tableFeature.setCurrentCell(non_valid_number_index[0],
non_valid_number_index[1] + 1)
self.tableFeature.setEditTriggers(old_edit_triggers)
else:
remove_features_with_same_value = RemoveSameFeatures()
self.data_container = remove_features_with_same_value.Run(
self.data_container)
if self.radioSplitRandom.isChecked(
) or self.radioSplitRef.isChecked():
folder_name = QFileDialog.getExistingDirectory(
self, "Save data")
if folder_name != '':
data_separate = DataSeparate.DataSeparate()
try:
if self.__testing_ref_data_container.IsEmpty():
testing_data_percentage = self.spinBoxSeparate.value(
)
if self.__clinical_ref.size == 0:
training_data_container, _, = \
data_separate.RunByTestingPercentage(self.data_container,
testing_data_percentage,
store_folder=folder_name)
else:
training_data_container, _, = \
data_separate.RunByTestingPercentage(self.data_container,
testing_data_percentage,
clinic_df=self.__clinical_ref,
store_folder=folder_name)
else:
training_data_container, _, = \
data_separate.RunByTestingReference(self.data_container,
self.__testing_ref_data_container,
folder_name)
if training_data_container.IsEmpty():
QMessageBox.information(
self, 'Error',
'The testing data does not mismatch, please check the testing data '
'really exists in current data')
return None
os.system("explorer.exe {:s}".format(
os.path.normpath(folder_name)))
except Exception as e:
content = 'PrepareConnection, splitting failed: '
eclog(self._filename).GetLogger().error(
'Split Error: ' + e.__str__())
QMessageBox.about(self, content, e.__str__())
else:
file_name, _ = QFileDialog.getSaveFileName(
self, "Save data", filter="csv files (*.csv)")
if file_name:
self.data_container.Save(file_name)
def __init__(self):
self.logger = eclog(os.path.split(__file__)[-1]).GetLogger()
def __init__(self):
self.__model = None
self._x = np.array([])
self._y = np.array([])
self._data_container = DataContainer()
self.logger = eclog(os.path.split(__file__)[-1]).GetLogger()
