Image projection with screen markers

contrib/app/sofast/SofastCommandLineInterface.py

@@ -485,8 +485,8 @@ def _run_given_input(self, retval: str) -> None:
  image_acquisition_in.frame_size = (1626, 1236)
  image_acquisition_in.gain = 230
 
- image_projection_in = ImageProjection.load_from_hdf_and_display(file_image_projection)
- image_projection_in.display_data['image_delay'] = 200
+ image_projection_in = ImageProjection.load_from_hdf(file_image_projection)
+ image_projection_in.display_data.image_delay_ms = 200
 
  camera_in = Camera.load_from_hdf(file_camera)
  facet_definition_in = DefinitionFacet.load_from_json(file_facet_definition_json)

example/sofast_calibration/example_calibration_screen_shape.py

@@ -6,7 +6,7 @@
 from opencsp.app.sofast.lib.MeasurementSofastFringe import MeasurementSofastFringe
 from opencsp.app.sofast.lib.CalibrateDisplayShape import CalibrateDisplayShape, DataInput
 from opencsp.common.lib.camera.Camera import Camera
-from opencsp.common.lib.deflectometry.ImageProjection import ImageProjection
+from opencsp.common.lib.deflectometry.ImageProjection import ImageProjectionData
 from opencsp.common.lib.geometry.Vxyz import Vxyz
 from opencsp.common.lib.opencsp_path.opencsp_root_path import opencsp_code_dir
 import opencsp.common.lib.tool.file_tools as ft
@@ -61,7 +61,7 @@ def example_screen_shape_calibration():
 
  # Load input data
  camera = Camera.load_from_hdf(file_camera_distortion)
- image_projection_data = ImageProjection.load_from_hdf(file_image_projection)
+ image_projection_data = ImageProjectionData.load_from_hdf(file_image_projection)
  screen_cal_point_pairs = np.loadtxt(file_screen_cal_point_pairs, delimiter=',', skiprows=1, dtype=int)
 
  # Store input data in data class

example/sofast_fixed/example_create_dot_pattern_from_display_shape.py

@@ -2,8 +2,8 @@
 
 from opencsp.app.sofast.lib.DotLocationsFixedPattern import DotLocationsFixedPattern
 from opencsp.app.sofast.lib.DisplayShape import DisplayShape
-from opencsp.app.sofast.lib.SystemSofastFixed import SystemSofastFixed
-from opencsp.common.lib.deflectometry.ImageProjection import ImageProjection
+from opencsp.app.sofast.lib.PatternSofastFixed import PatternSofastFixed
+from opencsp.common.lib.deflectometry.ImageProjection import ImageProjectionData
 from opencsp.common.lib.opencsp_path.opencsp_root_path import opencsp_code_dir
 import opencsp.common.lib.tool.file_tools as ft
 import opencsp.common.lib.tool.log_tools as lt
@@ -33,15 +33,17 @@ def example_calculate_dot_locations_from_display_shape():
 
  # Load data
  display = DisplayShape.load_from_hdf(file_display)
- im_proj_params = ImageProjection.load_from_hdf(file_image_projection)
+ im_proj_params = ImageProjectionData.load_from_hdf(file_image_projection)
 
  # 2. Define dot projection object
  # ===============================
  width_dot = 3 # pixels
  spacing_dot = 6 # pixels
 
  # Create fixed pattern projection object
- projection = SystemSofastFixed(im_proj_params['size_x'], im_proj_params['size_y'], width_dot, spacing_dot)
+ projection = PatternSofastFixed(
+ im_proj_params.active_area_size_x, im_proj_params.active_area_size_y, width_dot, spacing_dot
+ )
 
  # 3. Define DotLocationsFixedPattern object
  # =========================================

opencsp/app/sofast/SofastGUI.py

@@ -20,7 +20,7 @@
 from opencsp.common.lib.camera.ImageAcquisitionAbstract import ImageAcquisitionAbstract
 from opencsp.common.lib.camera.image_processing import highlight_saturation
 from opencsp.common.lib.camera.LiveView import LiveView
-from opencsp.common.lib.deflectometry.ImageProjection import ImageProjection
+from opencsp.common.lib.deflectometry.ImageProjection import ImageProjection, ImageProjectionData
 from opencsp.common.lib.geometry.Vxyz import Vxyz
 import opencsp.common.lib.opencsp_path.opencsp_root_path as orp
 import opencsp.common.lib.tool.exception_tools as et
@@ -46,7 +46,7 @@ def __init__(self) -> 'SofastGUI':
  self.root.title('SOFAST')
 
  # Set size of GUI
- self.root.geometry('600x640+200+100')
+ self.root.geometry('600x680+200+100')
 
  # Add all buttons/widgets to window
  self._create_layout()
@@ -136,6 +136,7 @@ def _plot_image(self, ax: plt.Axes, image: np.ndarray, title: str = '', xlabel:
 
  @functools.cached_property
  def cam_options(self):
+ """Returns all camera (ImageAcquisition) options that are compatible with Sofast"""
  all_cam_options = ImageAcquisitionAbstract.cam_options()
 
  ret: dict[str, type[ImageAcquisitionAbstract]] = {}
@@ -187,10 +188,17 @@ def _create_layout(self) -> None:
  # =============== First Column - Projection controls ===============
  r = 0
  self.btn_show_cal_image = tkinter.Button(
- label_frame_projector, text='Show Calibration Image', command=self.show_calibration_image
+ label_frame_projector, text='Show Cal Fiducial Image', command=self.show_calibration_fiducial_image
  )
  self.btn_show_cal_image.grid(row=r, column=0, pady=2, padx=2, sticky='nesw')
- tkt.TkToolTip(self.btn_show_cal_image, 'Shows calibration image on projection window.')
+ tkt.TkToolTip(self.btn_show_cal_image, 'Shows calibration fiducial image on projection window.')
+ r += 1
+
+ self.btn_show_cal_image = tkinter.Button(
+ label_frame_projector, text='Show Cal Marker Image', command=self.show_calibration_marker_image
+ )
+ self.btn_show_cal_image.grid(row=r, column=0, pady=2, padx=2, sticky='nesw')
+ tkt.TkToolTip(self.btn_show_cal_image, 'Shows calibration marker image on projection window.')
  r += 1
 
  self.btn_show_axes = tkinter.Button(label_frame_projector, text='Show Screen Axes', command=self.show_axes)
@@ -309,7 +317,10 @@ def _create_layout(self) -> None:
  # Camera type dropdown
  self.var_cam_select = tkinter.StringVar(value=list(self.cam_options.keys())[0])
  lbl_camera_type = tkinter.Label(label_frame_settings, text='Select camera:', font=('calibre', 10, 'bold'))
- drop_camera_type = tkinter.OptionMenu(label_frame_settings, self.var_cam_select, *list(self.cam_options.keys()))
+ cam_options = list(self.cam_options.keys())
+ drop_camera_type = tkinter.OptionMenu(
+ label_frame_settings, self.var_cam_select, cam_options[0], *cam_options[1:]
+ )
  tkt.TkToolTip(drop_camera_type, 'Select type of camera object to load.')
 
  lbl_camera_type.grid(row=r, column=1, pady=2, padx=2, sticky='nse')
@@ -547,13 +558,13 @@ def load_image_projection(self) -> None:
 
  # Load file and display
  if file != '':
- # Load data
- image_projection_data = ImageProjection.load_from_hdf(file)
  # Close the previous projector instance
  with et.ignored(Exception):
  ImageProjection.instance().close()
  # Create new window
  projector_root = tkt.window(self.root, TopLevel=True)
+ # Load data
+ image_projection_data = ImageProjectionData.load_from_hdf(file)
  # Show window
  ImageProjection(projector_root, image_projection_data)
  # Build system instance
@@ -565,13 +576,21 @@ def load_image_projection(self) -> None:
 
  lt.info(f'ImageProjection loaded:\n {file}')
 
- def show_calibration_image(self) -> None:
- """Shows calibration image"""
+ def show_calibration_fiducial_image(self) -> None:
+ """Shows calibration image with fiducials"""
+ # Check that we have a projector
+ if not self._check_projector_loaded('show_calibration_fiducial_image'):
+ return
+
+ ImageProjection.instance().show_calibration_fiducial_image()
+
+ def show_calibration_marker_image(self) -> None:
+ """Shows calibration image with Aruco markers"""
  # Check that we have a projector
- if not self._check_projector_loaded('show_calibration_image'):
+ if not self._check_projector_loaded('show_calibration_marker_image'):
  return
 
- ImageProjection.instance().show_calibration_image()
+ ImageProjection.instance().show_calibration_marker_image()
 
  def show_crosshairs(self) -> None:
  """Shows crosshairs"""
@@ -800,6 +819,7 @@ def _projector_closed(self, image_projection: ImageProjection):
  self._camera_closed(None)
 
  def close_image_acquisition(self) -> None:
+ """Closes image acquisition"""
  # Close the camera
  with et.ignored(Exception):
  ImageAcquisitionAbstract.instance().close()

opencsp/app/sofast/lib/CalibrateDisplayShape.py

@@ -17,7 +17,7 @@
 import opencsp.app.sofast.lib.image_processing as ip
 from opencsp.app.sofast.lib.MeasurementSofastFringe import MeasurementSofastFringe
 from opencsp.common.lib.camera.Camera import Camera
-from opencsp.common.lib.deflectometry.ImageProjection import CalParams
+from opencsp.common.lib.deflectometry.ImageProjection import CalParams, ImageProjectionData
 from opencsp.common.lib.geometry.Vxy import Vxy
 from opencsp.common.lib.geometry.Vxyz import Vxyz
 import opencsp.common.lib.photogrammetry.photogrammetry as ph
@@ -41,7 +41,7 @@ class DataInput:
  Aruco marker corners, meters
  camera : Camera
  Camera object used to capture screen distortion data
- image_projection_data : dict
+ image_projection_data : ImageProjectionData
  Image projection parameters
  measurements_screen : list[MeasurementSofastFringe]
  Screen shape Sofast measurement objects
@@ -56,7 +56,7 @@ class DataInput:
  resolution_xy: tuple[int, int]
  pts_xyz_marker: Vxyz
  camera: Camera
- image_projection_data: dict
+ image_projection_data: ImageProjectionData
  measurements_screen: list[MeasurementSofastFringe]
  assume_located_points: bool = True
  ray_intersection_threshold: float = 0.001
@@ -113,7 +113,8 @@ def __init__(self, data_input: DataInput) -> 'CalibrateDisplayShape':
 
  # Load cal params
  cal_pattern_params = CalParams(
- self.data_input.image_projection_data['size_x'], self.data_input.image_projection_data['size_y']
+ self.data_input.image_projection_data.active_area_size_x,
+ self.data_input.image_projection_data.active_area_size_y,
  )
 
  # Initialize calculation data structure

opencsp/app/sofast/lib/SystemSofastFixed.py

@@ -58,7 +58,7 @@ def __init__(self, image_acquisition: ImageAcquisitionAbstract) -> 'SystemSofast
  """The value that corresponds to pure white"""
  self.dot_shape: Literal['circle', 'square'] = 'circle'
  """The shape of the fixed pattern dots"""
- self.image_delay = image_projection.display_data['image_delay'] # ms
+ self.image_delay = image_projection.display_data.image_delay_ms # ms
  """The delay after displaying the image to capturing an image, ms"""
 
  def set_pattern_parameters(self, width_pattern: int, spacing_pattern: int):
@@ -76,8 +76,8 @@ def set_pattern_parameters(self, width_pattern: int, spacing_pattern: int):
  lt.debug(f'SystemSofastFixed fixed pattern dot width set to {width_pattern:d} pixels')
  lt.debug(f'SystemSofastFixed fixed pattern dot spacing set to {spacing_pattern:d} pixels')
  image_projection = ImageProjection.instance()
- size_x = image_projection.size_x
- size_y = image_projection.size_y
+ size_x = image_projection.display_data.active_area_size_x
+ size_y = image_projection.display_data.active_area_size_y
  self.pattern_sofast_fixed = PatternSofastFixed(size_x, size_y, width_pattern, spacing_pattern)
  self.pattern_image = self.pattern_sofast_fixed.get_image(self.dtype, self.max_int, self.dot_shape)
 

opencsp/app/sofast/lib/SystemSofastFringe.py

@@ -1,6 +1,3 @@
-"""Class for controlling displaying Sofast patterns and capturing images
-"""
-
 import copy
 import datetime as dt
 from typing import Callable
@@ -21,6 +18,8 @@
 
 
 class SystemSofastFringe:
+ """Class for controlling/displaying Sofast patterns and capturing images"""
+
  def __init__(
  self, image_acquisition: ImageAcquisitionAbstract | list[ImageAcquisitionAbstract] = None
  ) -> 'SystemSofastFringe':
@@ -40,7 +39,6 @@ def __init__(
  Either the image_acquisition or the image_projection has not been loaded.
  TypeError:
  The image_acquisition is not the correct type.
-
  """
  # Import here to avoid circular dependencies
  import opencsp.app.sofast.lib.sofast_common_functions as scf
@@ -206,7 +204,9 @@ def _create_mask_images_to_display(self) -> None:
  array = np.array(image_projection.get_black_array_active_area())
  self._mask_images_to_display.append(array)
  # Create white image
- array = np.array(image_projection.get_black_array_active_area()) + image_projection.max_int
+ array = (
+ np.array(image_projection.get_black_array_active_area()) + image_projection.display_data.projector_max_int
+ )
  self._mask_images_to_display.append(array)
 
  def _measure_sequence_display(
@@ -233,7 +233,7 @@ def _measure_sequence_display(
 
  # Wait, then capture image
  self.root.after(
- image_projection.display_data['image_delay'],
+ image_projection.display_data.image_delay_ms,
  lambda: self._measure_sequence_capture(im_disp_list, im_cap_list, run_next),
  )
 
@@ -306,13 +306,13 @@ def create_fringe_images_from_image_calibration(self):
  min_display_value = self._calibration.calculate_min_display_camera_values()[0]
 
  # Get fringe range
- fringe_range = (min_display_value, image_projection.display_data['projector_max_int'])
+ fringe_range = (min_display_value, image_projection.display_data.projector_max_int)
 
  # Get fringe base images
  fringe_images_base = self.fringes.get_frames(
- image_projection.size_x,
- image_projection.size_y,
- image_projection.display_data['projector_data_type'],
+ image_projection.display_data.active_area_size_x,
+ image_projection.display_data.active_area_size_y,
+ image_projection.display_data.projector_data_type,
  fringe_range,
  )
 
@@ -541,11 +541,14 @@ def run_display_camera_response_calibration(self, res: int = 10, run_next: Calla
 
  # Generate grayscale values
  self._calibration_display_values = np.arange(
- 0, image_projection.max_int + 1, res, dtype=image_projection.display_data['projector_data_type']
+ 0,
+ image_projection.display_data.projector_max_int + 1,
+ res,
+ dtype=image_projection.display_data.projector_data_type,
  )
- if self._calibration_display_values[-1] != image_projection.max_int:
+ if self._calibration_display_values[-1] != image_projection.display_data.projector_max_int:
  self._calibration_display_values = np.concatenate(
- (self._calibration_display_values, [image_projection.max_int])
+ (self._calibration_display_values, [image_projection.display_data.projector_max_int])
  )
 
  # Generate grayscale images
@@ -554,8 +557,12 @@ def run_display_camera_response_calibration(self, res: int = 10, run_next: Calla
  # Create image
  array = (
  np.zeros(
- (image_projection.size_y, image_projection.size_x, 3),
- dtype=image_projection.display_data['projector_data_type'],
+ (
+ image_projection.display_data.active_area_size_y,
+ image_projection.display_data.active_area_size_x,
+ 3,
+ ),
+ dtype=image_projection.display_data.projector_data_type,
  )
  + dn
  )

opencsp/app/sofast/lib/sofast_common_functions.py

@@ -186,7 +186,9 @@ def run_cal():
  if on_done is not None:
  on_done()
 
- white_image = np.array(image_projection.get_black_array_active_area()) + image_projection.max_int
+ white_image = (
+ np.array(image_projection.get_black_array_active_area()) + image_projection.display_data.projector_max_int
+ )
  image_projection.display_image_in_active_area(white_image)
  image_projection.root.after(100, run_cal)
 

opencsp/app/sofast/test/test_CalibrateDisplayShape.py

@@ -13,7 +13,7 @@
 from opencsp.app.sofast.lib.CalibrateDisplayShape import CalibrateDisplayShape, DataInput
 from opencsp.app.sofast.lib.MeasurementSofastFringe import MeasurementSofastFringe
 from opencsp.common.lib.camera.Camera import Camera
-from opencsp.common.lib.deflectometry.ImageProjection import ImageProjection
+from opencsp.common.lib.deflectometry.ImageProjection import ImageProjectionData
 from opencsp.common.lib.geometry.Vxyz import Vxyz
 from opencsp.common.lib.opencsp_path.opencsp_root_path import opencsp_code_dir
 from opencsp.common.lib.tool.hdf5_tools import load_hdf5_datasets
@@ -47,7 +47,7 @@ def setUpClass(cls):
  corner_ids = pts_marker_data[:, 1]
  screen_cal_point_pairs = np.loadtxt(file_screen_cal_point_pairs, delimiter=',', skiprows=1).astype(int)
  camera = Camera.load_from_hdf(file_camera_distortion)
- image_projection_data = ImageProjection.load_from_hdf(file_image_projection)
+ image_projection_data = ImageProjectionData.load_from_hdf(file_image_projection)
 
  # Store input data in data class
  data_input = DataInput(

opencsp/app/sofast/test/test_SystemSofastFixed.py

@@ -20,7 +20,7 @@ def test_system(self):
  file_im_proj = join(opencsp_code_dir(), 'test/data/sofast_common/image_projection_test.h5')
 
  # Instantiate image projection class
- im_proj = ImageProjection.load_from_hdf_and_display(file_im_proj)
+ im_proj = ImageProjection.load_from_hdf(file_im_proj)
 
  # Instantiate image acquisition class
  im_aq = ImageAcquisition()