Find centre of rotation (tentative 2)

MANIFEST.in

@@ -3,11 +3,10 @@ include README.md
 include *.yaml
 recursive-include * *.yaml
 recursive-include * *.yml
-recursive-include tests *.py
 recursive-include examples *.py
-recursive-include tests *.png
 recursive-include images *.png
 
 recursive-exclude * __pycache__
 recursive-exclude * *.py[co]
 recursive-exclude docs *
+recursive-exclude tests *

derotation/analysis/full_derotation_pipeline.py

@@ -168,14 +168,21 @@
         self.debugging_plots = self.config["debugging_plots"]
 
         if self.debugging_plots:
-            self.debug_plots_folder = self.config["paths_write"][
-                "debug_plots_folder"
-            ]
-            Path(self.debug_plots_folder).mkdir(parents=True, exist_ok=True)
+            self.debug_plots_folder = Path(
+                self.config["paths_write"]["debug_plots_folder"]
+            )
+            self.debug_plots_folder.mkdir(parents=True, exist_ok=True)
 
         logging.info(f"Dataset {self.filename_raw} loaded")
         logging.info(f"Filename: {self.filename}")
 
+        #  by default the center of rotation is the center of the image
+        self.center_of_rotation = (
+            self.num_lines_per_frame // 2,
+            self.num_lines_per_frame // 2,
+        )
+        self.hooks = {}
+
     ### ----------------- Analog signals processing pipeline ------------- ###
     def process_analog_signals(self):
         """From the analog signals (frame clock, line clock, full rotation,
@@ -790,26 +797,39 @@
         plt.savefig(self.debug_plots_folder / "rotation_angles.png")
 
     ### ----------------- Derotation ----------------- ###
+
+    def plot_max_projection_with_center(self):
+        """Plots the maximum projection of the image stack with the center
+        of rotation.
+        This plot will be saved in the debug_plots folder.
+        Please inspect it to check that the center of rotation is correctly
+        placed.
+        """
+        logging.info("Plotting max projection with center...")
+
+        max_projection = np.max(self.image_stack, axis=0)
+
+        fig, ax = plt.subplots(1, 1, figsize=(5, 5))
+
+        ax.imshow(max_projection, cmap="gray")
+        ax.scatter(
+            self.center_of_rotation[0],
+            self.center_of_rotation[1],
+            color="red",
+            marker="x",
+        )
+
+        ax.spines["top"].set_visible(False)
+        ax.spines["right"].set_visible(False)
+
+        ax.axis("off")
+
+        plt.savefig(self.debug_plots_folder / "max_projection_with_center.png")
+
     def derotate_frames_line_by_line(self) -> np.ndarray:
-        """Rotates the image stack line by line, using the rotation angles
-        by line calculated from the analog signals.
-
-        Description of the algorithm:
-        - takes one line from the image stack
-        - creates a new image with only that line
-        - rotates the line by the given angle
-        - substitutes the line in the new image
-        - adds the new image to the rotated image stack
-
-        Edge cases and how they are handled:
-        - the rotation starts in the middle of the image -> the previous lines
-        are copied from the first frame
-        - the rotation ends in the middle of the image -> the remaining lines
-        are copied from the last frame
-
-        Before derotation, it finds the image offset, which is the peak of
-        the gaussian mixture model fitted to the image histogram. It is
-        useful to fill in the blank pixels that appear during the derotation.
+        """Wrapper for the function `derotate_an_image_array_line_by_line`.
+        Before calling the function, it finds the F0 image offset with
+        `find_image_offset`.
 
         Returns
         -------
@@ -818,12 +838,22 @@
         """
         logging.info("Starting derotation by line...")
 
+        if self.debugging_plots:
+            self.plot_max_projection_with_center()
+
         offset = self.find_image_offset(self.image_stack[0])
 
         rotated_image_stack = derotate_an_image_array_line_by_line(
             self.image_stack,
             self.rot_deg_line,
             blank_pixels_value=offset,
+            center=self.center_of_rotation,
+            plotting_hook_line_addition=self.hooks.get(
+                "plotting_hook_line_addition"
+            ),
+            plotting_hook_image_completed=self.hooks.get(
+                "plotting_hook_image_completed"
+            ),
         )
 
         logging.info("✨ Image stack rotated ✨")
@@ -833,6 +863,19 @@
     def find_image_offset(img):
         """Find the "F0", also called "image offset" for a given image.
 
+        Explanations
+        ------------
+        What is the image offset?
+        The PMT (photo-multiplier tube) adds an arbitrary offset to the
+        image that corresponds to 0 photons received. We can use a Gaussian
+        Mixture Model to find this offset by assuming that it will be the
+        smallest mean of the Gaussian components.
+
+        Why do we need to find it?
+        When we rotate the image, the pixels of the image that are not
+        sampled will be filled with the offset is order to correctly express
+        "0 photons received".
+
         Parameters
         ----------
         img : np.ndarray