update type annotations

mantidimaging/gui/windows/recon/model.py

@@ -37,35 +37,35 @@ def __init__(self, data_model: CorTiltPointQtModel):
         self._last_cor = ScalarCoR(0.0)
 
     @property
-    def last_result(self):
+    def last_result(self) -> None:
         return self._last_result
 
     @last_result.setter
     def last_result(self, value):
         self._last_result = value
 
     @property
-    def selected_row(self):
+    def selected_row(self) -> int:
         return self._selected_row
 
     @selected_row.setter
-    def selected_row(self, value):
+    def selected_row(self, value: int) -> None:
         self._selected_row = value
 
     @property
-    def preview_projection_idx(self):
+    def preview_projection_idx(self) -> int:
         return self._preview_projection_idx
 
     @preview_projection_idx.setter
-    def preview_projection_idx(self, value: int):
+    def preview_projection_idx(self, value: int) -> None:
         self._preview_projection_idx = value
 
     @property
-    def preview_slice_idx(self):
+    def preview_slice_idx(self) -> int:
         return self._preview_slice_idx
 
     @preview_slice_idx.setter
-    def preview_slice_idx(self, value: int):
+    def preview_slice_idx(self, value: int) -> None:
         self._preview_slice_idx = value
 
     @property
@@ -77,7 +77,7 @@ def last_cor(self, value):
         self._last_cor = value
 
     @property
-    def has_results(self):
+    def has_results(self) -> bool:
         return self.data_model.has_results
 
     def get_results(self) -> Tuple[ScalarCoR, Degrees, Slope]:
@@ -88,14 +88,14 @@ def images(self):
         return self._images
 
     @property
-    def num_points(self):
+    def num_points(self) -> int:
         return self.data_model.num_points
 
-    def initial_select_data(self, images: 'ImageStack'):
+    def initial_select_data(self, images: 'ImageStack') -> None:
         self._images = images
         self.reset_cor_model()
 
-    def reset_cor_model(self):
+    def reset_cor_model(self) -> None:
         self.data_model.clear_results()
 
         slice_idx, cor = self.find_initial_cor()
@@ -111,7 +111,7 @@ def find_initial_cor(self) -> Tuple[int, ScalarCoR]:
         cor = ScalarCoR(self.images.h_middle)
         return first_slice_to_recon, cor
 
-    def do_fit(self):
+    def do_fit(self) -> bool:
         # Ensure we have some sample data
         if self.images is None:
             raise ValueError('No image stack is provided')
@@ -182,23 +182,23 @@ def tilt_angle(self) -> Optional[Degrees]:
             return None
 
     @property
-    def cors(self):
+    def cors(self) -> np.ndarray:
         return self.data_model.cors
 
     @property
-    def slices(self):
+    def slices(self) -> np.ndarray:
         return self.data_model.slices
 
     @staticmethod
-    def load_allowed_recon_kwargs():
+    def load_allowed_recon_kwargs() -> dict:
         d = tomopy_allowed_kwargs()
         if CudaChecker().cuda_is_present():
             d.update(astra_allowed_kwargs())
             d.update(cil_allowed_kwargs())
         return d
 
     @staticmethod
-    def get_allowed_filters(alg_name: str):
+    def get_allowed_filters(alg_name: str) -> list:
         reconstructor = get_reconstructor_for(alg_name)
         return reconstructor.allowed_filters()
 
@@ -224,7 +224,7 @@ def set_precalculated(self, cor: ScalarCoR, tilt: Degrees):
         self.data_model.set_precalculated(cor, tilt)
         self.last_result = self.data_model.stack_properties
 
-    def is_current_stack(self, uuid: "uuid.UUID"):
+    def is_current_stack(self, uuid: "uuid.UUID") -> bool:
         return self.stack_id == uuid
 
     def get_slice_indices(self, num_cors: int) -> Tuple[int, Union[np.ndarray, Tuple[np.ndarray, Optional[float]]]]:

mantidimaging/gui/windows/recon/presenter.py

@@ -114,7 +114,7 @@ def notify(self, notification, slice_idx=None):
         except Exception as err:
             self.show_error(err, traceback.format_exc())
 
-    def do_algorithm_changed(self):
+    def do_algorithm_changed(self) -> None:
         alg_name = self.view.algorithm_name
         allowed_args = self.allowed_recon_kwargs[alg_name]
         for arg, widgets in self.restricted_arg_widgets.items():
@@ -129,7 +129,7 @@ def do_algorithm_changed(self):
         self.do_preview_reconstruct_slice()
         self.view.change_refine_iterations()
 
-    def set_stack_uuid(self, uuid):
+    def set_stack_uuid(self, uuid) -> None:
         if not self.view.isVisible():
             self.stack_selection_change_pending = True
             return
@@ -153,39 +153,39 @@ def set_stack_uuid(self, uuid):
         self.do_preview_reconstruct_slice(reset_roi=True)
         self._do_nan_zero_negative_check()
 
-    def _set_max_preview_indexes(self):
+    def _set_max_preview_indexes(self) -> None:
         images = self.model.images
         if images is not None:
             self.view.set_max_projection_index(images.num_projections - 1)
             self.view.set_max_slice_index(images.height - 1)
 
-    def set_preview_projection_idx(self, idx):
+    def set_preview_projection_idx(self, idx: int) -> None:
         self.model.preview_projection_idx = idx
         self.do_update_projection()
 
-    def set_preview_slice_idx(self, idx):
+    def set_preview_slice_idx(self, idx: int) -> None:
         self.model.preview_slice_idx = idx
         self.do_update_projection()
         self.do_preview_reconstruct_slice()
 
-    def set_row(self, row):
+    def set_row(self, row: int) -> None:
         self.model.selected_row = row
 
-    def get_pixel_size_from_images(self):
+    def get_pixel_size_from_images(self) -> float:
         if self.model.images is not None and self.model.images.pixel_size is not None:
             return self.model.images.pixel_size
         else:
             return 0.
 
-    def do_update_projection(self):
+    def do_update_projection(self) -> None:
         images = self.model.images
         if images is None:
             self.view.reset_projection_preview()
             return
         img_data = images.projection(self.model.preview_projection_idx)
         self.view.update_projection(img_data, self.model.preview_slice_idx, self.model.tilt_angle)
 
-    def handle_stack_changed(self):
+    def handle_stack_changed(self) -> None:
         if self.view.isVisible():
             self.model.reset_cor_model()
             self.do_update_projection()
@@ -209,13 +209,13 @@ def _find_next_free_slice_index(self) -> int:
 
         raise RuntimeError("No free slice indexes to add to the COR Table")
 
-    def do_add_cor(self):
+    def do_add_cor(self) -> None:
         row = self.model.selected_row
         cor = self.model.get_me_a_cor()
         slice_index = self._find_next_free_slice_index()
         self.view.add_cor_table_row(row, slice_index, cor.value)
 
-    def do_reconstruct_volume(self):
+    def do_reconstruct_volume(self) -> None:
         if not self.model.has_results:
             raise ValueError("Fit is not performed on the data, therefore the CoR cannot be found for each slice.")
 
@@ -319,7 +319,7 @@ def _do_refine_selected_cor(self):
             # Update reconstruction preview with new COR
             self.set_preview_slice_idx(slice_idx)
 
-    def _do_refine_iterations(self):
+    def _do_refine_iterations(self) -> None:
         slice_idx = self.model.preview_slice_idx
 
         dialog = CORInspectionDialogView(self.view, self.model.images, slice_idx, self.model.last_cor,
@@ -332,13 +332,13 @@ def _do_refine_iterations(self):
             LOG.debug('New optimal iterations: {}'.format(new_iters))
             self.view.num_iter = new_iters
 
-    def do_cor_fit(self):
+    def do_cor_fit(self) -> None:
         self.model.do_fit()
         self.view.set_results(*self.model.get_results())
         self.do_update_projection()
         self.do_preview_reconstruct_slice()
 
-    def _on_volume_recon_done(self, task):
+    def _on_volume_recon_done(self, task) -> None:
         self.recon_is_running = False
         if task.error is not None:
             self.view.show_error_dialog(f"Encountered error while trying to reconstruct: {str(task.error)}")
@@ -376,7 +376,7 @@ def _set_precalculated_cor_tilt(self, cor: ScalarCoR, tilt: Degrees):
         self.do_update_projection()
         self.do_preview_reconstruct_slice()
 
-    def _auto_find_correlation(self):
+    def _auto_find_correlation(self) -> None:
         if not self.model.images.has_proj180deg():
             self.view.show_status_message("Unable to correlate 0 and 180 because the dataset doesn't have a 180 "
                                           "projection set. Please load a 180 projection manually.")
@@ -402,7 +402,7 @@ def completed(task: TaskWorkerThread):
         self.view.set_correlate_buttons_enabled(False)
         start_async_task_view(self.view, self.model.auto_find_correlation, completed, tracker=self.async_tracker)
 
-    def _auto_find_minimisation_square_sum(self):
+    def _auto_find_minimisation_square_sum(self) -> None:
         num_cors = self.view.get_number_of_cors()
         if num_cors is None:
             return
@@ -418,7 +418,7 @@ def _auto_find_minimisation_square_sum(self):
         else:
             initial_cor = self.view.rotation_centre
 
-        def _completed_finding_cors(task: TaskWorkerThread):
+        def _completed_finding_cors(task: TaskWorkerThread) -> None:
             if task.error is not None:
                 self.view.show_error_dialog(f"Finding the COR failed.\n\n Error: {str(task.error)}")
             else:
@@ -438,10 +438,10 @@ def _completed_finding_cors(task: TaskWorkerThread):
                               },
                               tracker=self.async_tracker)
 
-    def proj_180_degree_shape_matches_images(self, images):
+    def proj_180_degree_shape_matches_images(self, images) -> bool:
         return self.model.proj_180_degree_shape_matches_images(images)
 
-    def _do_nan_zero_negative_check(self):
+    def _do_nan_zero_negative_check(self) -> None:
         """
         Checks if the data contains NaNs/zeroes and displays a message if they are found.
         """
@@ -460,7 +460,7 @@ def _do_nan_zero_negative_check(self):
             self.view.show_status_message(" ".join(msg_list))
 
     @staticmethod
-    def _replace_inf_nan(images: ImageStack):
+    def _replace_inf_nan(images: ImageStack) -> None:
         """
         Replaces infinity values in a data array with NaNs. Used because pyqtgraph has programs with arrays containing
         inf.

mantidimaging/gui/windows/recon/view.py

@@ -238,13 +238,13 @@ def check_stack_for_invalid_180_deg_proj(self, uuid: UUID):
                 "The shapes of the selected stack and it's 180 degree projections do not match! This is "
                 "going to cause an error when calculating the COR. Fix the shape before continuing!")
 
-    def remove_selected_cor(self):
+    def remove_selected_cor(self) -> None:
         return self.tableView.removeSelectedRows()
 
-    def clear_cor_table(self):
+    def clear_cor_table(self) -> None:
         return self.cor_table_model.removeAllRows()
 
-    def cleanup(self):
+    def cleanup(self) -> None:
         self.stackSelector.unsubscribe_from_main_window()
         self.image_view.cleanup()
         self.main_window.recon = None
@@ -256,7 +256,7 @@ def cor_table_model(self) -> CorTiltPointQtModel:
             self.tableView.setModel(mdl)
         return self.tableView.model()  # type: ignore
 
-    def set_results(self, cor: ScalarCoR, tilt: Degrees, slope: Slope):
+    def set_results(self, cor: ScalarCoR, tilt: Degrees, slope: Slope) -> None:
         """
         Sets the numerical COR and tilt angle results.
         """
@@ -265,7 +265,7 @@ def set_results(self, cor: ScalarCoR, tilt: Degrees, slope: Slope):
         self.slope = slope.value
         self.image_view.set_tilt(tilt)
 
-    def preview_image_on_button_press(self, event):
+    def preview_image_on_button_press(self, event) -> None:
         """
         Handles mouse button presses on the preview projection image.
 
@@ -322,13 +322,13 @@ def reset_recon_and_sino_previews(self):
         self.image_view.clear_recon()
         self.image_view.clear_sinogram()
 
-    def reset_recon_line_profile(self):
+    def reset_recon_line_profile(self) -> None:
         self.image_view.clear_recon_line_profile()
 
-    def reset_projection_preview(self):
+    def reset_projection_preview(self) -> None:
         self.image_view.clear_projection()
 
-    def reset_slice_and_tilt(self, slice_index):
+    def reset_slice_and_tilt(self, slice_index: int) -> None:
         self.image_view.reset_slice_and_tilt(slice_index)
 
     def on_table_row_count_change(self, _=None, __=None):
@@ -463,18 +463,18 @@ def set_table_point(self, idx, slice_idx, cor):
         # handled as an internal Qt event in the model
         self.cor_table_model.set_point(idx, slice_idx, cor, reset_results=False)
 
-    def show_recon_volume(self, data: ImageStack, stack_id: uuid.UUID):
+    def show_recon_volume(self, data: ImageStack, stack_id: uuid.UUID) -> None:
         self.main_window.add_recon_to_dataset(data, stack_id)
 
     def get_stack(self, uuid) -> Optional['ImageStack']:
         if uuid is not None:
             return self.main_window.get_stack(uuid)
         return None
 
-    def hide_tilt(self):
+    def hide_tilt(self) -> None:
         self.image_view.hide_tilt()
 
-    def set_filters_for_recon_tool(self, filters: List[str]):
+    def set_filters_for_recon_tool(self, filters: List[str]) -> None:
         self.filterName.clear()
         self.filterName.insertItems(0, filters)
 
@@ -499,20 +499,20 @@ def get_auto_cor_method(self) -> AutoCorMethod:
         else:
             return AutoCorMethod.MINIMISATION_SQUARE_SUM
 
-    def set_correlate_buttons_enabled(self, enabled: bool):
+    def set_correlate_buttons_enabled(self, enabled: bool) -> None:
         self.correlateBtn.setEnabled(enabled)
         self.minimiseBtn.setEnabled(enabled)
 
-    def open_help_webpage(self, page: str):
+    def open_help_webpage(self, page: str) -> None:
         try:
             open_help_webpage(SECTION_USER_GUIDE, page)
         except RuntimeError as err:
             self.show_error_dialog(str(err))
 
-    def change_refine_iterations(self):
+    def change_refine_iterations(self) -> None:
         self.refineIterationsBtn.setEnabled(self.algorithm_name == "SIRT_CUDA")
 
-    def on_change_colour_palette(self):
+    def on_change_colour_palette(self) -> None:
         """
         Opens the Palette Changer window when the "Auto" button has been clicked.
         """
@@ -522,7 +522,7 @@ def on_change_colour_palette(self):
                                                                recon_mode=True)
         self.change_colour_palette_dialog.show()
 
-    def show_status_message(self, msg: str):
+    def show_status_message(self, msg: str) -> None:
         """
         Shows a status message indicating that zero/negative/NaN pixels were found in the stack. If the msg argument is
         empty then this is taken to mean that no such pixels were found, so the warning message and icon are cleared.
@@ -534,12 +534,12 @@ def show_status_message(self, msg: str):
         else:
             self.messageIcon.clear()
 
-    def set_recon_buttons_enabled(self, enabled: bool):
+    def set_recon_buttons_enabled(self, enabled: bool) -> None:
         self.reconstructSlice.setEnabled(enabled)
         self.reconstructVolume.setEnabled(enabled)
 
-    def set_max_projection_index(self, max_index: int):
+    def set_max_projection_index(self, max_index: int) -> None:
         self.previewProjectionIndex.setMaximum(max_index)
 
-    def set_max_slice_index(self, max_index: int):
+    def set_max_slice_index(self, max_index: int) -> None:
         self.previewSliceIndex.setMaximum(max_index)