Minor overall fixing [skip ci]

Author: dbouget

gui/SinglePatientComponent/CentralAreaExecutionWidget.py

@@ -216,38 +216,3 @@ def on_run_reporting(self):
 
     def on_process_message(self, mess):
         print("Collected message: {}.\n".format(mess))
-
-    def assertion_input_compatible(self, tumor_type: str) -> bool:
-        # Making sure an MRI series with the proper sequence type has been loaded and tagged.
-        if tumor_type != 'Low-Grade Glioma':
-            valid_ids = SoftwareConfigResources.getInstance().get_active_patient().get_all_mri_volumes_for_sequence_type(MRISequenceType.T1c)
-            if len(valid_ids) == 0:
-                box = QMessageBox(self)
-                box.setWindowTitle("Missing contrast-enhanced MRI scan")
-                box.setText("Please make sure to load a contrast-enhanced MRI scan for running this task.\n"
-                            "Also make sure to properly fill in the sequence type attribute for the loaded "
-                            "MRI Series in the right-hand panel!")
-                box.setIcon(QMessageBox.Warning)
-                box.setStyleSheet("""QLabel{
-                color: rgba(0, 0, 0, 1);
-                background-color: rgba(255, 255, 255, 1);
-                }""")
-                box.exec()
-                return False
-        else:
-            valid_ids = SoftwareConfigResources.getInstance().get_active_patient().get_all_mri_volumes_for_sequence_type(MRISequenceType.FLAIR)
-            if len(valid_ids) == 0:
-                box = QMessageBox(self)
-                box.setWindowTitle("Missing FLAIR MRI scan")
-                box.setText("Please make sure to load a contrast-enhanced MRI scan for running this task.\n"
-                            "Also make sure to properly fill in the sequence type attribute for the loaded "
-                            "MRI Series in the right-hand panel!")
-                box.setIcon(QMessageBox.Warning)
-                box.setStyleSheet("""QLabel{
-                color: rgba(0, 0, 0, 1);
-                background-color: rgba(255, 255, 255, 1);
-                }""")
-                box.exec()
-                return False
-
-        return True

gui/SinglePatientComponent/LayersInteractorSidePanel/ActionsInteractor/ActionsInteractorWidget.py

@@ -117,7 +117,7 @@ def __set_advanced_interface(self):
         self.advanced_actions_groupbox_layout.addLayout(self.timestamp_target_layout)
         self.advanced_actions_groupbox_layout.addLayout(self.segmentation_class_layout)
         self.advanced_actions_groupbox_layout.addWidget(self.run_action_pushbutton)
-        self.layout.addWidget(self.advanced_actions_groupbox)
+        # self.layout.addWidget(self.advanced_actions_groupbox)  # Disabling for now, not sure how to have it.
 
     def __set_connections(self):
         self.run_folder_classification.clicked.connect(self.on_execute_folders_classification)
@@ -454,6 +454,7 @@ def reset(self):
         self.run_segmentation_postop.setEnabled(False)
         self.run_rads_preop.setEnabled(False)
         self.run_rads_postop.setEnabled(False)
+        self.run_rads_surgical.setStyleSheet(False)
         self.action_type_combobox.setEnabled(False)
         self.action_type_combobox.setCurrentIndex(0)
         self.timestamp_target_combobox.setEnabled(False)
@@ -478,11 +479,16 @@ def refresh(self) -> None:
         self.timestamp_target_combobox.addItems(items)
 
     def on_enable_actions(self):
+        """
+        @TODO. Should be triggered also when changing the active patient, if it has image content (right now if the
+        patient is loaded from the batch mode, it is not triggered).
+        """
         self.run_folder_classification.setEnabled(True)
         self.run_segmentation_preop.setEnabled(True)
         self.run_segmentation_postop.setEnabled(True)
         self.run_rads_preop.setEnabled(True)
         self.run_rads_postop.setEnabled(True)
+        self.run_rads_surgical.setEnabled(True)
         self.action_type_combobox.setEnabled(True)
         self.timestamp_target_combobox.setEnabled(True)
         self.segmentation_class_combobox.setEnabled(True)

gui/SinglePatientComponent/LayersInteractorSidePanel/TimestampsInteractor/TimestampsLayerInteractor.py

@@ -414,12 +414,19 @@ def on_radiological_sequences_imported(self):
             self.timestamps_widget[i].on_radiological_sequences_imported()
 
     def on_process_started(self) -> None:
-        self.timestamps_widget[list(self.timestamps_widget.keys())[self.timestamp_selector_combobox.currentIndex()]].on_process_started()
-        self.timestamp_add_pushbutton.setEnabled(False)
-        self.timestamp_remove_pushbutton.setEnabled(False)
+        """
+        When a process is starting, some options have to be disabled if viewing in single mode. Unsure what happens
+        when switching from study to patient mode while a batch process is ongoing...
+        While in study mode, the timestamp widgets are not created.
+        """
+        if len(self.timestamps_widget) != 0:
+            self.timestamps_widget[list(self.timestamps_widget.keys())[self.timestamp_selector_combobox.currentIndex()]].on_process_started()
+            self.timestamp_add_pushbutton.setEnabled(False)
+            self.timestamp_remove_pushbutton.setEnabled(False)
 
     def on_process_finished(self) -> None:
-        self.timestamps_widget[list(self.timestamps_widget.keys())[self.timestamp_selector_combobox.currentIndex()]].on_process_finished()
-        self.timestamp_add_pushbutton.setEnabled(True)
-        self.timestamp_remove_pushbutton.setEnabled(True)
-        self.timestamp_selector_combobox.setCurrentIndex(0)
+        if len(self.timestamps_widget) != 0:
+            self.timestamps_widget[list(self.timestamps_widget.keys())[self.timestamp_selector_combobox.currentIndex()]].on_process_finished()
+            self.timestamp_add_pushbutton.setEnabled(True)
+            self.timestamp_remove_pushbutton.setEnabled(True)
+            self.timestamp_selector_combobox.setCurrentIndex(0)

gui/SinglePatientComponent/PatientResultsSidePanel/SurgicalReportingWidget.py

@@ -69,6 +69,26 @@ def __set_interface(self):
         self.resection_category_layout.addWidget(self.resection_category_label)
         self.layout.addLayout(self.resection_category_layout)
 
+        self.postoperative_flairchanges_volume_layout = QHBoxLayout()
+        self.postoperative_flairchanges_volume_layout.setSpacing(0)
+        self.postoperative_flairchanges_volume_layout.setContentsMargins(0, 0, 0, 0)
+        self.postoperative_flairchanges_volume_header_label = QLabel("Postoperative FLAIR changes volume: ")
+        self.postoperative_flairchanges_volume_label = QLabel(" - ml")
+        self.postoperative_flairchanges_volume_layout.addWidget(self.postoperative_flairchanges_volume_header_label)
+        self.postoperative_flairchanges_volume_layout.addStretch(1)
+        self.postoperative_flairchanges_volume_layout.addWidget(self.postoperative_flairchanges_volume_label)
+        self.layout.addLayout(self.postoperative_flairchanges_volume_layout)
+
+        self.postoperative_cavity_volume_layout = QHBoxLayout()
+        self.postoperative_cavity_volume_layout.setSpacing(0)
+        self.postoperative_cavity_volume_layout.setContentsMargins(0, 0, 0, 0)
+        self.postoperative_cavity_volume_header_label = QLabel("Postoperative cavity volume: ")
+        self.postoperative_cavity_volume_label = QLabel(" - ml")
+        self.postoperative_cavity_volume_layout.addWidget(self.postoperative_cavity_volume_header_label)
+        self.postoperative_cavity_volume_layout.addStretch(1)
+        self.postoperative_cavity_volume_layout.addWidget(self.postoperative_cavity_volume_label)
+        self.layout.addLayout(self.postoperative_cavity_volume_layout)
+
         self.layout.addStretch(1)
 
     def __set_layout_dimensions(self):
@@ -84,6 +104,12 @@ def __set_layout_dimensions(self):
         self.resection_category_header_label.setFixedHeight(20)
         self.resection_category_label.setFixedHeight(20)
 
+        self.postoperative_flairchanges_volume_header_label.setFixedHeight(20)
+        self.postoperative_flairchanges_volume_label.setFixedHeight(20)
+
+        self.postoperative_cavity_volume_header_label.setFixedHeight(20)
+        self.postoperative_cavity_volume_label.setFixedHeight(20)
+
     def __set_connections(self):
         pass
 
@@ -159,6 +185,38 @@ def set_stylesheets(self, selected: bool) -> None:
         font-size:13px;
         }""")
 
+        self.postoperative_flairchanges_volume_header_label.setStyleSheet("""
+        QLabel{
+        color: """ + font_color + """;
+        text-align:left;
+        font:semibold;
+        font-size:14px;
+        }""")
+
+        self.postoperative_flairchanges_volume_label.setStyleSheet("""
+        QLabel{
+        color: """ + font_color + """;
+        text-align:right;
+        font:semibold;
+        font-size:14px;
+        }""")
+
+        self.postoperative_cavity_volume_header_label.setStyleSheet("""
+        QLabel{
+        color: """ + font_color + """;
+        text-align:left;
+        font:semibold;
+        font-size:14px;
+        }""")
+
+        self.postoperative_cavity_volume_label.setStyleSheet("""
+        QLabel{
+        color: """ + font_color + """;
+        text-align:right;
+        font:semibold;
+        font-size:14px;
+        }""")
+
     def adjustSize(self):
         pass
 
@@ -172,10 +230,14 @@ def populate_from_report(self) -> None:
             # No report has been generated for the patient, skipping the rest.
             return
 
-        self.preoperative_tumor_volume_label.setText(str(report_json['preop_volume']) + ' ml')
-        self.postoperative_tumor_volume_label.setText(str(report_json['postop_volume']) + ' ml')
-        self.extent_resection_label.setText(str(np.round(report_json['eor'], 2)) + ' %')
+        self.preoperative_tumor_volume_label.setText(str(round(report_json['preop_volume'], 3)) + ' ml')
+        self.postoperative_tumor_volume_label.setText(str(round(report_json['postop_volume'], 3)) + ' ml')
+        self.extent_resection_label.setText(str(round(report_json['eor'], 2)) + ' %')
         self.resection_category_label.setText(report_json['resection_category'])
+        if report_json['flairchanges_postop_volume'] is not None:
+            self.postoperative_flairchanges_volume_label.setText(str(round(report_json['flairchanges_postop_volume'], 3)) + ' ml')
+        if report_json['cavity_postop_volume'] is not None:
+            self.postoperative_cavity_volume_label.setText(str(round(report_json['cavity_postop_volume'], 3)) + ' ml')
 
     def on_size_request(self):
         self.resizeRequested.emit()

gui/StudyBatchComponent/StudiesSidePanel/SingleStudyWidget.py

@@ -152,7 +152,7 @@ def __set_batch_processing_part(self):
         self.batch_processing_layout.setContentsMargins(0, 0, 0, 0)
         self.batch_processing_combobox = QComboBox()
         self.batch_processing_combobox.addItems(["folders_classification", "preop_segmentation", "preop_reporting",
-                                                 "postop_segmentation", "postop_reporting"])
+                                                 "postop_segmentation", "postop_reporting", "surgical_reporting"])
         self.batch_processing_run_pushbutton = QPushButton()
         self.batch_processing_run_pushbutton.setToolTip("Execute the selected process.")
         self.batch_processing_run_pushbutton.setIcon(QIcon(QPixmap(os.path.join(os.path.dirname(os.path.realpath(__file__)),
@@ -593,22 +593,10 @@ def __on_run_pipeline(self) -> None:
 
             if code == 0:  # Operation was cancelled by the user
                 return
-
-            if diag.tumor_type == 'Glioblastoma':
-                self.model_name = "MRI_GBM"
-            elif diag.tumor_type == 'Low-Grade Glioma':
-                self.model_name = "MRI_LGGlioma"
-            elif diag.tumor_type == 'Metastasis':
-                self.model_name = "MRI_Metastasis"
-            elif diag.tumor_type == 'Meningioma':
-                self.model_name = "MRI_Meningioma"
-            if UserPreferencesStructure.getInstance().segmentation_tumor_model_type != "Tumor":
-                self.model_name = self.model_name + '_multiclass'
-                if diag.tumor_type == 'Low-Grade Glioma':
-                    self.model_name = "MRI_GBM_multiclass"
+            self.tumor_type = diag.tumor_type
 
         self.on_processing_started()
-        self.batch_pipeline_execution_requested.emit(self.uid, pipeline_task, self.model_name)
+        self.batch_pipeline_execution_requested.emit(self.uid, pipeline_task, self.tumor_type)
 
     def on_patients_loading_started(self):
         self.include_single_patient_folder_pushbutton.setEnabled(False)

gui/StudyBatchComponent/StudiesSidePanel/StudiesSidePanelWidget.py

@@ -298,9 +298,9 @@ def on_study_imported(self, study_uid):
             self.single_study_widgets[study_uid].manual_header_pushbutton_clicked(True)
             self.__on_study_selection(True, study_uid)
 
-    def on_batch_pipeline_execution_requested(self, study_id, pipeline_task, model_name):
+    def on_batch_pipeline_execution_requested(self, study_id, pipeline_task, tumor_type):
         self.bottom_add_study_pushbutton.setEnabled(False)
-        self.batch_pipeline_execution_requested.emit(study_id, pipeline_task, model_name)
+        self.batch_pipeline_execution_requested.emit(study_id, pipeline_task, tumor_type)
 
     def on_processing_advanced(self):
         self.single_study_widgets[SoftwareConfigResources.getInstance().active_study_name].on_processing_advanced()

gui/StudyBatchComponent/StudyBatchWidget.py

@@ -161,21 +161,21 @@ def on_study_imported(self, study_uid: str):
         for pat_uid in SoftwareConfigResources.getInstance().get_study(study_uid).included_patients_uids.keys():
             self.patient_imported.emit(pat_uid)
 
-    def on_batch_pipeline_execution_wrapper(self, study_uid: str, pipeline_task: str, model_name: str) -> None:
+    def on_batch_pipeline_execution_wrapper(self, study_uid: str, pipeline_task: str, tumor_type: str) -> None:
         run_segmentation_thread = threading.Thread(target=self.on_batch_pipeline_execution, args=(study_uid,
                                                                                                   pipeline_task,
-                                                                                                  model_name,))
+                                                                                                  tumor_type,))
         run_segmentation_thread.daemon = True  # using daemon thread the thread is killed gracefully if program is abruptly closed
         run_segmentation_thread.start()
 
-    def on_batch_pipeline_execution(self, study_uid, pipeline_task, model_name):
+    def on_batch_pipeline_execution(self, study_uid, pipeline_task, tumor_type):
         from utils.backend_logic import pipeline_main_wrapper
         self.on_process_started()
         study = SoftwareConfigResources.getInstance().study_parameters[study_uid]
         patients_uid = study.included_patients_uids
         for u in patients_uid:
             code, results = pipeline_main_wrapper(pipeline_task=pipeline_task,
-                                                  model_name=model_name,
+                                                  tumor_type=tumor_type,
                                                   patient_parameters=SoftwareConfigResources.getInstance().patients_parameters[u])
             # Not iterating over the image results as the redrawing will be done when the active patient is changed.
             if 'Report' in list(results.keys()):

gui/UtilsWidgets/CustomQDialog/SoftwareSettingsDialog.py

@@ -196,7 +196,7 @@ def __set_processing_segmentation_options_interface(self):
         self.processing_segmentation_models_inputs_groupbox.setTitle("Segmentation models inputs")
         self.processing_segmentation_models_inputs_groupboxlayout = QVBoxLayout()
         self.processing_segmentation_models_inputs_groupbox.setLayout(self.processing_segmentation_models_inputs_groupboxlayout)
-        self.processing_segmentation_options_base_layout.addWidget(self.processing_segmentation_models_inputs_groupbox)
+        # self.processing_segmentation_options_base_layout.addWidget(self.processing_segmentation_models_inputs_groupbox)
 
         self.processing_segmentation_models_groupbox = QGroupBox()
         self.processing_segmentation_models_groupbox.setTitle("Segmentation models runtime")

utils/logic/PipelineCreationHandler.py

@@ -444,32 +444,16 @@ def __create_surgical_reporting_pipeline(tumor_type: str) -> dict:
 
     return pip
 
-def __create_custom_pipeline(task, tumor_type, patient_parameters):
+def __create_custom_pipeline(task: str, tumor_type: str, patient_parameters: PatientParameters) -> dict:
     split_task = task.split('_')
     pip = {}
     pip_num_int = 0
 
     if split_task[0] == "Classification":
-        pip_num_int = pip_num_int + 1
-        pip_num = str(pip_num_int)
-        pip[pip_num] = {}
-        pip[pip_num]["task"] = 'Classification'
-        pip[pip_num]["inputs"] = {}
-        pip[pip_num]["target"] = ["MRSequence"]
-        pip[pip_num]["model"] = 'MRI_SequenceClassifier'
-        pip[pip_num]["description"] = "Classification of the MRI sequence type for all input scans"
-        download_model(model_name='MRI_SequenceClassifier')
+        include_radiological_volume_classifier(pip=pip, pip_num_start=pip_num_int)
     elif split_task[0] == "Segmentation":
         if not UserPreferencesStructure.getInstance().use_manual_sequences:
-            pip_num_int = pip_num_int + 1
-            pip_num = str(pip_num_int)
-            pip[pip_num] = {}
-            pip[pip_num]["task"] = 'Classification'
-            pip[pip_num]["inputs"] = {}
-            pip[pip_num]["target"] = ["MRSequence"]
-            pip[pip_num]["model"] = 'MRI_SequenceClassifier'
-            pip[pip_num]["description"] = "Classification of the MRI sequence type for all input scans"
-            download_model(model_name='MRI_SequenceClassifier')
+            include_radiological_volume_classifier(pip=pip, pip_num_start=pip_num_int)
 
         base_model_name = "MRI_" if SoftwareConfigResources.getInstance().software_medical_specialty == "neurology" else "CT_"
         timestamp_order = int(split_task[2][1:])