Merge pull request #286 from sandialabs/revert-231-230-code-feature-update-most-of-the-image-processors-for-spotanalysis

Revert "230 code feature update most of the image processors for spotanalysis"

Author: jehsharp

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

@@ -5,7 +5,7 @@
 import cv2 as cv
 import numpy as np
 
-from contrib.common.lib.cv.spot_analysis.PixelOfInterest import PixelOfInterest
+from contrib.common.lib.cv.spot_analysis.PixelLocation import PixelOfInterest
 from opencsp.common.lib.cv.CacheableImage import CacheableImage
 import opencsp.common.lib.geometry.Pxy as p2
 import opencsp.common.lib.render.Color as color
@@ -45,9 +45,9 @@ def __init__(
         """
         Parameters
         ----------
-        center_locator: Callable[[SpotAnalysisOperable], tuple[int, int]] | tuple[int, int] | str | PixelOfInterest, optional
+        center_locator: Callable[[SpotAnalysisOperable], tuple[int, int]] | tuple[int, int] | str | PixelLocation, optional
             The pixel location in the image from which to start measureing the
-            enclosed energy. See :py:class:`PixelOfInterest` for more details.
+            enclosed energy. See :py:class:`PixelLocation` for more details.
         enclosed_shape: str, optional
             The shape to use for calculating enclosed energy. Options are
             "circle" or "square". Default is "cirle".

opencsp/common/lib/csp/StandardPlotOutput.py

@@ -251,7 +251,7 @@ def source_path(self, new_val: str | None):
                             ValueError,
                             "Error in CacheableImage.source_path(): "
                             + f"the contents of self.nparray and {new_val} do not match!"
-                            + f" ({self.cache_path=}, {self._source_path=})",
+                            + f" ({self.cache_path=}, {self.source_path=})",
                         )
 
         self._source_path = new_val
@@ -355,7 +355,7 @@ def from_single_source(
         elif isinstance(array_or_path, str):
             path: str = array_or_path
             if path.lower().endswith(".npy"):
-                return cls(cache_path_name_ext=path)
+                return cls(cache_path=path)
             return cls(source_path=path)
         elif isinstance(array_or_path, np.ndarray):
             array: np.ndarray = array_or_path

opencsp/common/lib/cv/CacheableImage.py

@@ -16,27 +16,24 @@
 from opencsp.common.lib.cv.spot_analysis.SpotAnalysisOperable import SpotAnalysisOperable
 from opencsp.common.lib.cv.spot_analysis.SpotAnalysisOperablesStream import _SpotAnalysisOperablesStream
 from opencsp.common.lib.cv.spot_analysis.SpotAnalysisOperableAttributeParser import SpotAnalysisOperableAttributeParser
-from opencsp.common.lib.cv.spot_analysis.SpotAnalysisPipeline import SpotAnalysisPipeline
 from opencsp.common.lib.cv.spot_analysis.VisualizationCoordinator import VisualizationCoordinator
 import opencsp.common.lib.render.VideoHandler as vh
 import opencsp.common.lib.opencsp_path.opencsp_root_path as orp
 import opencsp.common.lib.tool.file_tools as ft
+import opencsp.common.lib.tool.image_tools as it
 import opencsp.common.lib.tool.log_tools as lt
 
 
-class SpotAnalysis(Iterator[SpotAnalysisOperable]):
+class SpotAnalysis(Iterator[tuple[SpotAnalysisOperable]]):
     """Spot Analysis class for characterizing beams of light.
 
     This is meant to be a general beam characterization tool that receives as
     input an image (or video) of a single beam, and generates annotations and
     numerical statistics as output. In general, there is an image processing
     step, an image analysis step, and a visualization step. Any number of
     processors and analyzers can be chained together to form a pipeline for
-    evaluation.
-
-    Once defined, a SpotAnalysis instance can evaluate any number of input
-    images with either the :py:meth:`set_primary_images` or
-    :py:meth:`set_input_operables` methods.
+    evaluation. Once defined, a SpotAnalysis instance can be used to evaluate
+    one image/video per evaluation.
 
     A list of possible use cases for this class include:
         a. BCS
@@ -179,12 +176,15 @@ def __init__(
         cases listed above. """
         self.image_processors: list[AbstractSpotAnalysisImageProcessor] = []
         """ List of processors, one per step of the analysis. The output from
-        each processor can include one or more operables, and is made available
-        to all subsequent processors. """
+        each processor can include one or more images (or numeric values), and
+        is made available to all subsequent processors. """
+        self._results_iter: Iterator[SpotAnalysisOperable] = None
+        """ The returned value from iter(self.image_processors[-1]). Initialized
+        on the first call to process_next(). """
+        self._prev_result: SpotAnalysisOperable = None
+        """ The previously returned result. """
         self.input_stream: _SpotAnalysisOperablesStream = None
         """ The images to be processed. """
-        self._processing_pipeline: SpotAnalysisPipeline = None
-        """ The current iterator and evaluation pipeline. """
         self.save_dir: str = save_dir
         """ If not None, then primary images will be saved to the given
         directory as a PNG after having been fully processed. """
@@ -206,19 +206,26 @@ def __init__(
         all values here will be made available for processing as the default
         values. """
         self.visualization_coordinator = VisualizationCoordinator()
-        """ Manages interactive viewing of all visualization image processors. """
+        """ Shows the same image from all visualization processors at the same time. """
 
         self.set_image_processors(image_processors)
 
     def set_image_processors(self, image_processors: list[AbstractSpotAnalysisImageProcessor]):
         self.image_processors = image_processors
 
+        # chain the image processors together
+        for i, image_processor in enumerate(self.image_processors):
+            if i == 0:
+                continue
+            image_processor.assign_inputs(self.image_processors[i - 1])
+
         # register the visualization processors
         self.visualization_coordinator.clear()
         self.visualization_coordinator.register_visualization_processors(image_processors)
 
-        # register the image processors for in-flight results
-        self._operables_in_flight = {processor: [] for processor in image_processors}
+        # assign the input stream to the first image processor
+        if self.input_stream != None:
+            self._assign_inputs(self.input_stream)
 
     @staticmethod
     def _images2stream(
@@ -230,16 +237,11 @@ def _images2stream(
             return ImagesIterable(images)
 
     def _assign_inputs(self, input_operables: Iterator[SpotAnalysisOperable]):
-        # sanitize arguments
         if not isinstance(input_operables, _SpotAnalysisOperablesStream):
             input_operables = _SpotAnalysisOperablesStream(input_operables)
-
-        # assign inputs
         self.input_stream = input_operables
-
-        # reset temporary values
         self._prev_result = None
-        self.set_image_processors(self.image_processors)
+        self.image_processors[0].assign_inputs(self.input_stream)
 
     def set_primary_images(self, images: list[str] | list[np.ndarray] | vh.VideoHandler | ImagesStream):
         """Assigns the images of the spot to be analyzed, in preparation for process_next().
@@ -252,55 +254,31 @@ def set_primary_images(self, images: list[str] | list[np.ndarray] | vh.VideoHand
             handler instance set with a video to be broken into frames, or an
             images stream.
 
-        Notes
-        -----
-        Only one of set_primary_images or :py:meth:`set_input_operables` should
-        be used to assign input images.
-        """
+        See also: set_input_operables()"""
         primary_images = self._images2stream(images)
         images_stream = SpotAnalysisImagesStream(primary_images, {})
-        self._assign_inputs(images_stream)
+        self._assign_inputs(_SpotAnalysisOperablesStream(images_stream))
 
     def set_input_operables(
         self,
         input_operables: _SpotAnalysisOperablesStream | list[SpotAnalysisOperable] | Iterator[SpotAnalysisOperable],
     ):
         """Assigns primary and supporting images, and other necessary data, in preparation for process_next().
 
-        Notes
-        -----
-        Only one of set_primary_images or :py:meth:`set_input_operables` should
-        be used to assign input images.
-        """
+        See also: set_primary_images()"""
         self._assign_inputs(input_operables)
 
     def set_default_support_images(self, support_images: dict[ImageType, CacheableImage]):
         """Provides extra support images for use during image processing, as a
         default for when the support images are not otherwise from the input
         operables. Note that this does not include the primary images or other
         data."""
-        # check for state consistency
-        if self.input_stream is None:
-            lt.error_and_raise(
-                RuntimeError,
-                "Error in SpotAnalysis.set_default_support_images(): "
-                + "must call set_input_operables() or set_primary_images() first.",
-            )
-
         self.input_stream.set_defaults(support_images, self.input_stream.default_data)
 
     def set_default_data(self, operable: SpotAnalysisOperable):
         """Provides extra data for use during image processing, as a default
         for when the data is not otherwise from the input operables. Note that
         this does not include the primary or supporting images."""
-        # check for state consistency
-        if self.input_stream is None:
-            lt.error_and_raise(
-                RuntimeError,
-                "Error in SpotAnalysis.set_default_data(): "
-                + "must call set_input_operables() or set_primary_images() first.",
-            )
-
         self.input_stream.set_defaults(self.input_stream.default_support_images, operable)
 
     def process_next(self):
@@ -313,22 +291,23 @@ def process_next(self):
             The processed primary image and other associated data. None if done
             processing.
         """
-        last_processor = self.image_processors[-1]
+        if self._results_iter is None:
+            self._results_iter = iter(self.image_processors[-1])
 
-        # sanity check
-        if self.input_stream is None:
-            lt.error_and_raise(
-                RuntimeError,
-                "Error in SpotAnalysis.process_next(): "
-                + "must assign inputs via set_primary_images() or set_input_operables() first.",
-            )
+        # Release memory from the previous result
+        if self._prev_result is not None:
+            self.image_processors[-1].cache_images_to_disk_as_necessary()
+            self._prev_result = None
 
-        # Create the processing pipeline, as necessary
-        if self._processing_pipeline is None:
-            self._initialize_processing_pipeline()
+        # Attempt to get the next image. Raises StopIteration if there are no
+        # more results available.
+        try:
+            result = next(self._results_iter)
+        except StopIteration:
+            return None
 
-        # Get the next result
-        return self._processing_pipeline.process_next()
+        self._prev_result = result
+        return result
 
     def _save_image(self, save_path_name_ext: str, image: CacheableImage, description: str):
         # check for overwrite
@@ -348,7 +327,7 @@ def _save_image(self, save_path_name_ext: str, image: CacheableImage, descriptio
         if save_ext in ["np", "npy"]:
             np.save(save_path_name_ext, image.nparray, allow_pickle=False)
         else:
-            image.to_image().save(save_path_name_ext)
+            it.numpy_to_image(image.nparray).save(save_path_name_ext)
 
         return True
 
@@ -392,17 +371,16 @@ def save_image(
         # Save the resulting processed image
         if save_dir != None:
             # Get the original file name
-            orig_image_name = ""
-            orig_image_path, orig_image_name_ext = operable.get_primary_path_nameext()
-            if orig_image_name_ext != None:
-                _, orig_image_name, orig_image_ext = ft.path_components(orig_image_name_ext)
-                orig_image_name += "_"
+            orig_image_path_name = ""
+            if operable.primary_image.source_path != None:
+                _, orig_image_path_name, _ = ft.path_components(operable.primary_image.source_path)
+                orig_image_path_name += "_"
 
             # Get the output name of the file to save to
             sa_name_appendix = ft.convert_string_to_file_body(self.name)
-            image_name = f"{orig_image_name}{sa_name_appendix}"
+            image_name = f"{orig_image_path_name}{sa_name_appendix}"
             if image_name in self.saved_names:
-                image_name = f"{orig_image_name}{sa_name_appendix}_{self.save_idx}"
+                image_name = f"{orig_image_path_name}{sa_name_appendix}_{self.save_idx}"
                 self.save_idx += 1
             self.saved_names.add(image_name)
             image_path_name_ext = os.path.join(save_dir, f"{image_name}.{save_ext}")
@@ -437,14 +415,12 @@ def save_image(
 
         return image_path_name_ext
 
-    def _initialize_processing_pipeline(self):
-        self._processing_pipeline = SpotAnalysisPipeline(self.image_processors, iter(self.input_stream))
-
     def __iter__(self):
-        self._initialize_processing_pipeline()
+        self.save_idx = 0
+        self._prev_result = None
         return self
 
-    def __next__(self) -> SpotAnalysisOperable:
+    def __next__(self):
         ret = self.process_next()
         if ret == None:
             raise StopIteration
@@ -469,7 +445,7 @@ def __next__(self) -> SpotAnalysisOperable:
         PopulationStatisticsImageProcessor(min_pop_size=-1),
         EchoImageProcessor(),
         LogScaleImageProcessor(),
-        ViewFalseColorImageProcessor(),
+        FalseColorImageProcessor(),
     ]
     sa = SpotAnalysis("BCS Test", image_processors, save_dir=outdir, save_overwrite=True)
     image_name_exts = ft.files_in_directory(indir)

opencsp/common/lib/cv/SpotAnalysis.py

@@ -1,6 +1,5 @@
 from opencsp.common.lib.cv.annotations.PointAnnotations import PointAnnotations
 import opencsp.common.lib.geometry.Pxy as p2
-import opencsp.common.lib.render.Color as color
 import opencsp.common.lib.render_control.RenderControlPointSeq as rcps
 
 
@@ -50,8 +49,5 @@ def __init__(self, style: rcps.RenderControlPointSeq = None, point: p2.Pxy = Non
         """
         # "ChatGPT 4o" assisted with generating this docstring.
         if style is None:
-            style = rcps.default(color=color.magenta(), marker='x')
+            style = rcps.RenderControlPointSeq(color="blue", marker="x", markersize=1)
         super().__init__(style, point)
-
-    def __str__(self):
-        return f"HotspotAnnotation<{self.points.x[0]},{self.points.y[0]}>"