Merge pull request #294 from bbean23/293-code-feature-spotanalysis-examples-35-bcs-image-on-tower-east-side

293 code feature spotanalysis examples 35 bcs image on tower east side

Author: rcbrost

.gitignore

@@ -10,6 +10,9 @@
 # Virtual environment
 env/
 
+# Configuration files
+experiment_settings.ini
+
 # Ben's Sublime files.
 sftp-config.json
 

contrib/common/lib/cv/annotations/RectangleAnnotations.py

@@ -1,6 +1,3 @@
-import matplotlib.axes
-import matplotlib.collections
-import matplotlib.patches
 import numpy as np
 import scipy.spatial.transform
 
@@ -11,8 +8,8 @@
 import opencsp.common.lib.render.Color as color
 import opencsp.common.lib.render.figure_management as fm
 import opencsp.common.lib.render.view_spec as vs
-import opencsp.common.lib.render.View3d as v3d
 import opencsp.common.lib.render_control.RenderControlAxis as rca
+import opencsp.common.lib.render_control.RenderControlFigureRecord as rcfr
 import opencsp.common.lib.render_control.RenderControlPointSeq as rcps
 import opencsp.common.lib.tool.log_tools as lt
 

contrib/common/lib/cv/annotations/SpotWidthAnnotation.py

@@ -1,20 +1,12 @@
-import matplotlib.axes
 import matplotlib.patches
 import numpy as np
 import scipy.spatial.transform
-import scipy.special
 
 from opencsp.common.lib.cv.annotations.AbstractAnnotations import AbstractAnnotations
 import opencsp.common.lib.geometry.Pxy as p2
 import opencsp.common.lib.geometry.RegionXY as reg
 import opencsp.common.lib.geometry.Vxy as v2
 
-import opencsp.common.lib.render.Color as color
-import opencsp.common.lib.render.figure_management as fm
-import opencsp.common.lib.render.view_spec as vs
-import opencsp.common.lib.render.View3d as v3d
-import opencsp.common.lib.render_control.RenderControlAxis as rca
-import opencsp.common.lib.render_control.RenderControlFigure as rcfg
 import opencsp.common.lib.render_control.RenderControlFigureRecord as rcfr
 import opencsp.common.lib.render_control.RenderControlSpotSize as rcss
 

contrib/common/lib/cv/annotations/test/TestImportAnnotations.py

@@ -0,0 +1,13 @@
+import unittest
+
+
+class TestImportAnnotations(unittest.TestCase):
+    def test_import(self):
+        """Tests that we can import the annotations without encountering a cyclic import error."""
+        import contrib.common.lib.cv.annotations.MomentsAnnotation
+        import contrib.common.lib.cv.annotations.RectangleAnnotations
+        import contrib.common.lib.cv.annotations.SpotWidthAnnotation
+
+
+if __name__ == "__main__":
+    unittest.main()

contrib/common/lib/cv/spot_analysis/image_processor/EnclosedEnergyImageProcessor.py

@@ -79,6 +79,13 @@ def __init__(
                 "Error in EnclosedEnergyImageProcessor(): "
                 + f"enclosed_shape must be one of {allowed_shapes}, but is '{enclosed_shape}'",
             )
+        if percentages_of_interest is not None:
+            if not np.all([poi >= 0 and poi <= 1.0 for poi in percentages_of_interest]):
+                lt.error_and_raise(
+                    ValueError,
+                    "Error in EnclosedEnergyImageProcessor(): "
+                    + f"percentages_of_interest must be between 0 and 1 but {percentages_of_interest=}!",
+                )
 
         # use default values
         if enclosed_energy_style is None:
@@ -182,6 +189,9 @@ def calculate_enclosed_energy(self, image: CacheableImage, center_location: tupl
 
         # Sanity checks
         assert len(enclosed_energy_sums) == max_radius + 1
+        assert np.all(
+            [enclosed_energy_sums[i] >= enclosed_energy_sums[i - 1] for i in range(1, len(enclosed_energy_sums))]
+        )
 
         if enclosed_energy_sums[-1] != total_energy:
             lt.error_and_raise(
@@ -192,7 +202,7 @@ def calculate_enclosed_energy(self, image: CacheableImage, center_location: tupl
 
         return enclosed_energy_sums, example_enclosed_image
 
-    def build_enclosed_energy_plot(self, enclosed_energy_sums: list[int]) -> np.ndarray:
+    def build_enclosed_energy_plot(self, enclosed_energy_sums: list[int]) -> tuple[np.ndarray, dict[float, int]]:
         """
         Builds a plot of the enclosed energy around the central_locator of the input image.
 
@@ -209,29 +219,35 @@ def build_enclosed_energy_plot(self, enclosed_energy_sums: list[int]) -> np.ndar
         -------
         plot_image: np.ndarray
             A np.ndarray containing the enclosed energy plot.
+        percentages_of_interest_radiuses: dict[float,int]
+            The radiuses (in pixels) at which the enclosed energy of
+            interest percentages are first reached.
         """
         # Determine the axes ranges
         if self.plot_x_limit_pixels > 0:
             x_range = self.plot_x_limit_pixels
         else:
             x_range = len(enclosed_energy_sums)
 
-        # Build the data as a fraction of the total
+        # Build the data as a fraction of the total.
         pq_vals: list[tuple[int, int]] = []
-        enclosed_energy_fractions: list[float] = []
+        enclosed_energy_fractions: list[tuple[int, int, float]] = []
         total_enclosed_energy = enclosed_energy_sums[-1]
         for radius in range(len(enclosed_energy_sums)):
-            enclosed_energy_fractions.append(enclosed_energy_sums[radius] / total_enclosed_energy)
+            enclosed_energy_fractions.append(
+                tuple([radius, enclosed_energy_sums[radius], enclosed_energy_sums[radius] / total_enclosed_energy])
+            )
             pq_vals.append(tuple([radius, enclosed_energy_fractions[radius - 1]]))
         assert len(enclosed_energy_fractions) == len(enclosed_energy_sums)
 
         # Pad the plot for the given plot_x_limit_pixels, if any is given
         for radius in range(len(pq_vals) + 1, x_range + 1):
-            pq_vals.append(tuple(radius, enclosed_energy_fractions[-1]))
+            pq_vals.append(tuple(radius, enclosed_energy_fractions[-1][2]))
 
         # Limit the plot to the x range
+        print(f"{len(pq_vals)=}")
         pq_vals = pq_vals[: x_range + 1]
-        assert len(pq_vals) == x_range + 1
+        assert len(pq_vals) == x_range, f"{len(pq_vals)=} != {x_range=}"
 
         # Create a new figure for the plot
         figure_control = rcfg.RenderControlFigure()
@@ -247,15 +263,19 @@ def build_enclosed_energy_plot(self, enclosed_energy_sums: list[int]) -> np.ndar
         )
 
         # Draw the percentages of interest
+        percentages_of_interest_radii: dict[float, int] = {}
         if self.percentages_of_interest is not None:
             for poi in sorted(self.percentages_of_interest):
-                closest_radius, closest_dist = 0, np.abs(poi - enclosed_energy_fractions[0])
-                for radius, fraction in enumerate(enclosed_energy_fractions):
+                closest_radius, closest_dist = 0, np.abs(poi - enclosed_energy_fractions[0][2])
+                for radius, enclosed_energy_sum, fraction in enclosed_energy_fractions:
                     dist = np.abs(fraction - poi)
                     if dist < closest_dist:
                         closest_radius = radius
                         closest_dist = dist
+
                 lt.info(f"Percentage of interest {poi} is at radius {closest_radius}")
+                percentages_of_interest_radii[poi] = closest_radius
+
                 fig_record.view.draw_pq_list(
                     [(0, poi), (closest_radius, poi)], style=self.percentages_of_interest_style.measured
                 )
@@ -273,7 +293,7 @@ def build_enclosed_energy_plot(self, enclosed_energy_sums: list[int]) -> np.ndar
         # close the figure
         fig_record.close()
 
-        return plot_image
+        return plot_image, percentages_of_interest_radii
 
     def _execute(self, operable: SpotAnalysisOperable, is_last: bool) -> list[SpotAnalysisOperable]:
         # Calculate the enclosed energy around the central_locator of the image
@@ -283,11 +303,11 @@ def _execute(self, operable: SpotAnalysisOperable, is_last: bool) -> list[SpotAn
         )
 
         # Generate a visual plot of the enclosed energy
-        enclosed_energy_plot = self.build_enclosed_energy_plot(enclosed_energy_sums)
+        enclosed_energy_plot, percentages_of_interest_radii = self.build_enclosed_energy_plot(enclosed_energy_sums)
 
         # Build the new operable
         notes = copy.copy(operable.image_processor_notes)
-        notes.append(tuple([self.name, [str(v) for v in enclosed_energy_sums]]))
+        notes.append(tuple([self.name, tuple([percentages_of_interest_radii, [str(v) for v in enclosed_energy_sums]])]))
         algorithm_images = copy.copy(operable.algorithm_images)
         algorithm_images[self] = [CacheableImage.from_single_source(example_enclosed_energy_image)]
         vis_images = copy.copy(operable.visualization_images)

contrib/common/lib/cv/spot_analysis/image_processor/PowerpointImageProcessor.py

@@ -137,7 +137,7 @@ def __init__(
                 lt.error_and_raise(
                     TypeError,
                     "Error in PowerpointImageProcessor.__init__(): "
-                    + f'"processors_per_slide" is a {type(processors_per_slide)}, but should be a list of lists',
+                    + f'"processors_per_slide" is a {processors_per_slide.__name__}, but should be a list of lists',
                 )
             else:
                 for i, processor_set in enumerate(processors_per_slide):
@@ -147,23 +147,23 @@ def __init__(
                         lt.error_and_raise(
                             TypeError,
                             "Error in PowerpointImageProcessor.__init__(): "
-                            + f'"processors_per_slide[{i}]" is a {type(processor_set)}, but should be a list!',
+                            + f'"processors_per_slide[{i}]" is a {processor_set.__name__}, but should be a list!',
                         )
                     for j, processor_sel in enumerate(processor_set):
-                        processor_sel_type = type(processor_sel)
                         # normalize to use ProcOrImg
                         if not isinstance(processor_sel, ProcessorSelector):
                             if not isinstance(processor_sel, tuple):
                                 processor_sel = tuple([processor_sel])
                             try:
                                 processors_per_slide[i][j] = ProcessorSelector.from_tuple(processor_sel)
                             except TypeError:
+                                processor_sel_name = processor_sel.__class__.__name__
                                 lt.error_and_raise(
                                     TypeError,
                                     "Error in PowerpointImageProcessor.__init__(): "
-                                    + f'"processors_per_slide[{i}][{j}]" is a {processor_sel_type}, '
-                                    + f"but should be an {type(AbstractSpotAnalysisImageProcessor)}, "
-                                    + f"{type(CacheableImage)}, or image-like!",
+                                    + f'"processors_per_slide[{i}][{j}]" is a {processor_sel_name}, '
+                                    + f"but should be an {AbstractSpotAnalysisImageProcessor.__name__}, "
+                                    + f"{CacheableImage.__name__}, or image-like!",
                                 )
 
         # register the rest of the input arguments

contrib/common/lib/cv/spot_analysis/image_processor/SpotWidthImageProcessor.py

@@ -1,12 +1,11 @@
 import copy
 import dataclasses
 import json
+from typing import TYPE_CHECKING
 
 import cv2 as cv
 import numpy as np
 
-from contrib.common.lib.cv.annotations.SpotWidthAnnotation import SpotWidthAnnotation
-from contrib.common.lib.cv.annotations.MomentsAnnotation import MomentsAnnotation
 from opencsp.common.lib.cv.CacheableImage import CacheableImage
 import opencsp.common.lib.cv.image_reshapers as ir
 from opencsp.common.lib.cv.spot_analysis.SpotAnalysisOperable import SpotAnalysisOperable
@@ -20,6 +19,11 @@
 import opencsp.common.lib.tool.image_tools as it
 import opencsp.common.lib.tool.log_tools as lt
 
+if TYPE_CHECKING:
+    # don't import at runtime to avoid cyclic imports
+    from contrib.common.lib.cv.annotations.SpotWidthAnnotation import SpotWidthAnnotation
+    from contrib.common.lib.cv.annotations.MomentsAnnotation import MomentsAnnotation
+
 
 class SpotWidthImageProcessor(AbstractSpotAnalysisImageProcessor):
     """
@@ -68,6 +72,9 @@ def locate_half_max_pixels(self, image: np.ndarray) -> tuple[np.ndarray, np.ndar
         return np.where(image == half_max)
 
     def find_centroid(self, coords: tuple[np.ndarray, np.ndarray]) -> p2.Pxy:
+        # import here to avoid cyclic imports
+        from contrib.common.lib.cv.annotations.MomentsAnnotation import MomentsAnnotation
+
         # create an image with 1s at the specified coordinates
         y_max = np.max(coords[0])
         x_max = np.max(coords[1])
@@ -215,6 +222,9 @@ def fwhm(self, image_name: str, image: np.ndarray) -> tuple[p2.Pxy, float, float
         return centroid, long_axis_width, long_axis_rotation, long_axis_center, orthogonal_axis_width, algorithm_image
 
     def _execute(self, operable: SpotAnalysisOperable, is_last: bool) -> list[SpotAnalysisOperable]:
+        # import here to avoid cyclic imports
+        from contrib.common.lib.cv.annotations.SpotWidthAnnotation import SpotWidthAnnotation
+
         image = operable.primary_image.nparray
         annotations = copy.copy(operable.annotations)
         notes = copy.copy(operable.image_processor_notes)