add progress_updater support to detect_markers, gaze_to_plane, make_gaze_overlay_video, make_mapped_gaze_video, run_validation for more granular and complete progress output

Author: dcnieho

src/gazeMapper/process/detect_markers.py

@@ -9,7 +9,7 @@
 from .. import config, episode, marker, naming, plane, process, session, synchronization
 
 
-def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show_visualization=False, visualization_show_rejected_markers=False, **study_settings):
+def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show_visualization=False, visualization_show_rejected_markers=False, progress_indicator: process_pool.JobProgress=None, **study_settings):
     # if show_visualization, each frame is shown in a viewer, overlaid with info about detected markers and planes
     # if show_rejected_markers, rejected ArUco marker candidates are also shown in the viewer. Possibly useful for debug
     working_dir = pathlib.Path(working_dir)
@@ -29,15 +29,21 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show
         gui.set_show_play_percentage(True)
         gui.set_show_action_tooltip(True)
 
-        proc_thread = propagating_thread.PropagatingThread(target=do_the_work, args=(working_dir, config_dir, gui, visualization_show_rejected_markers), kwargs=study_settings, cleanup_fun=gui.stop)
+        proc_thread = propagating_thread.PropagatingThread(target=do_the_work, args=(working_dir, config_dir, gui, visualization_show_rejected_markers, progress_indicator), kwargs=study_settings, cleanup_fun=gui.stop)
         proc_thread.start()
         gui.start()
         proc_thread.join()
     else:
-        do_the_work(working_dir, config_dir, None, False, **study_settings)
+        do_the_work(working_dir, config_dir, None, False, progress_indicator, **study_settings)
 
 
-def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: GUI, visualization_show_rejected_markers: bool, **study_settings):
+def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: GUI, visualization_show_rejected_markers: bool, progress_indicator: process_pool.JobProgress, **study_settings):
+    # progress indicator
+    if progress_indicator is None:
+        progress_indicator = process_pool.JobProgress(printer=lambda x: print(x))
+    progress_indicator.set_unit('frames')
+    progress_indicator.set_start_time_to_now()
+
     # get settings for the study
     study_config = config.read_study_config_with_overrides(config_dir, {config.OverrideLevel.Session: working_dir.parent, config.OverrideLevel.Recording: working_dir}, **study_settings)
 
@@ -102,6 +108,12 @@ def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: GUI, v
             colors['rejected_marker_color'] = study_config.mapped_video_rejected_marker_color or (255,0,0)
         aruco_manager.set_visualization_colors(**colors)
 
+    # prep progress indicator
+    total = estimator.video_ts.get_last()[0]
+    progress_indicator.set_total(total)
+    progress_indicator.set_intervals(int(total/200), int(total/200))
+    estimator.set_progress_updater(progress_indicator.update)
+
     poses, individual_markers, sync_target_signal = estimator.process_video()
 
     for p in poses:

src/gazeMapper/process/gaze_to_plane.py

@@ -7,7 +7,7 @@
 from .. import config, episode, naming, plane, process, session, synchronization
 
 
-def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show_visualization=False, show_planes=True, show_only_intervals=True, **study_settings):
+def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show_visualization=False, show_planes=True, show_only_intervals=True, progress_indicator: process_pool.JobProgress=None, **study_settings):
     # if show_visualization, each frame is shown in a viewer, overlaid with info about detected planes and projected gaze
     # if show_poster, gaze in space of each plane is also drawn in a separate windows
     # if show_only_intervals, only the coded mapping episodes (if available) are shown in the viewer while the rest of the scene video is skipped past
@@ -26,15 +26,21 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show
         gui.set_show_play_percentage(True)
         gui.set_show_action_tooltip(True)
 
-        proc_thread = propagating_thread.PropagatingThread(target=do_the_work, args=(working_dir, config_dir, gui, show_planes, show_only_intervals), kwargs=study_settings, cleanup_fun=gui.stop)
+        proc_thread = propagating_thread.PropagatingThread(target=do_the_work, args=(working_dir, config_dir, gui, show_planes, show_only_intervals, progress_indicator), kwargs=study_settings, cleanup_fun=gui.stop)
         proc_thread.start()
         gui.start()
         proc_thread.join()
     else:
-        do_the_work(working_dir, config_dir, None, False, False, **study_settings)
+        do_the_work(working_dir, config_dir, None, False, False, progress_indicator, **study_settings)
 
 
-def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: GUI, show_planes: bool, show_only_intervals: bool, **study_settings):
+def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: GUI, show_planes: bool, show_only_intervals: bool, progress_indicator: process_pool.JobProgress, **study_settings):
+    # progress indicator
+    if progress_indicator is None:
+        progress_indicator = process_pool.JobProgress(printer=lambda x: print(x))
+    progress_indicator.set_unit('samples')
+    progress_indicator.set_start_time_to_now()
+
     # get settings for the study
     study_config = config.read_study_config_with_overrides(config_dir, {config.OverrideLevel.Session: working_dir.parent, config.OverrideLevel.Recording: working_dir}, **study_settings)
 
@@ -77,13 +83,17 @@ def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: GUI, s
     head_gazes = gaze_headref.read_dict_from_file(working_dir / gt_naming.gaze_data_fname, processing_intervals if should_load_part else None, ts_column_suffixes=['VOR', ''])[0]
     poses = {p:gt_pose.read_dict_from_file(working_dir/f'{naming.plane_pose_prefix}{p}.tsv', mapping_setup[p] if should_load_part else None) for p in mapping_setup}
 
+    # prep progress indicator
+    total = sum(len(head_gazes[f]) for p in poses for f in poses[p] if f in head_gazes)
+    progress_indicator.set_total(total)
+    progress_indicator.set_intervals(int(total/200), int(total/200))
     # get camera calibration info
     camera_params = ocv.CameraParams.read_from_file(working_dir / gt_naming.scene_camera_calibration_fname)
 
     # transform gaze to plane(s)
     plane_gazes: dict[str, dict[int,list[gaze_worldref.Gaze]]] = {}
     for p in planes:
-        plane_gazes[p] = gaze_worldref.from_head(poses[p], head_gazes, camera_params)
+        plane_gazes[p] = gaze_worldref.from_head(poses[p], head_gazes, camera_params, progress_indicator.update)
         gaze_worldref.write_dict_to_file(plane_gazes[p], working_dir/f'{naming.world_gaze_prefix}{p}.tsv', skip_missing=True)
 
     # update state

src/gazeMapper/process/make_gaze_overlay_video.py

@@ -6,7 +6,7 @@
 from .. import config, process, session
 
 
-def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show_visualization=False, **study_settings):
+def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show_visualization=False, progress_indicator: process_pool.JobProgress=None, **study_settings):
     # if show_visualization, each frame is shown in a viewer as video is generated
     working_dir = pathlib.Path(working_dir)
     if config_dir is None:
@@ -25,15 +25,21 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show
         gui.set_show_action_tooltip(True)
         gui.set_button_props_for_action(video_player.Action.Quit, 'Stop', tooltip='Interrupt (cut short) the video generation')
 
-        proc_thread = propagating_thread.PropagatingThread(target=do_the_work, args=(working_dir, config_dir, gui), kwargs=study_settings, cleanup_fun=gui.stop)
+        proc_thread = propagating_thread.PropagatingThread(target=do_the_work, args=(working_dir, config_dir, gui, progress_indicator), kwargs=study_settings, cleanup_fun=gui.stop)
         proc_thread.start()
         gui.start()
         proc_thread.join()
     else:
-        do_the_work(working_dir, config_dir, None, **study_settings)
+        do_the_work(working_dir, config_dir, None, progress_indicator, **study_settings)
 
 
-def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: video_player.GUI, **study_settings):
+def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: video_player.GUI, progress_indicator: process_pool.JobProgress, **study_settings):
+    # progress indicator
+    if progress_indicator is None:
+        progress_indicator = process_pool.JobProgress(printer=lambda x: print(x))
+    progress_indicator.set_unit('frames')
+    progress_indicator.set_start_time_to_now()
+
     # get settings for the study
     study_config = config.read_study_config_with_overrides(config_dir, {config.OverrideLevel.Session: working_dir.parent, config.OverrideLevel.Recording: working_dir}, **study_settings)
 
@@ -52,11 +58,16 @@ def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: video_
     if gui is not None:
         gui.set_show_timeline(True, video_ts, window_id=gui.main_window_id)
 
+    # prep progress indicator
+    total = video_ts.get_last()[0]
+    progress_indicator.set_total(total)
+    progress_indicator.set_intervals(int(total/200), int(total/200))
+
     # update state: set to not run so that if we crash or cancel below the task is correctly marked as not run (video files are corrupt)
     session.update_action_states(working_dir, process.Action.MAKE_GAZE_OVERLAY_VIDEO, process_pool.State.Not_Run, study_config)
 
     # now run
-    video_maker.process_video()
+    video_maker.process_video(progress_indicator.update)
 
     # update state
     session.update_action_states(working_dir, process.Action.MAKE_GAZE_OVERLAY_VIDEO, process_pool.State.Completed, study_config)

src/gazeMapper/process/make_mapped_gaze_video.py

@@ -19,7 +19,7 @@
 from .detect_markers import _get_plane_setup, _get_sync_function
 
 
-def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show_visualization=False, **study_settings):
+def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show_visualization=False, progress_indicator: process_pool.JobProgress=None, **study_settings):
     # if show_visualization, the generated video(s) are shown as they are created in a viewer
     working_dir  = pathlib.Path(working_dir) # working directory of a session, not of a recording
     if config_dir is None:
@@ -32,17 +32,23 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, show
         gui = video_player.GUI(use_thread = False)
         gui.add_window(working_dir.name)
 
-        proc_thread = propagating_thread.PropagatingThread(target=do_the_work, args=(working_dir, config_dir, gui), kwargs=study_settings, cleanup_fun=gui.stop)
+        proc_thread = propagating_thread.PropagatingThread(target=do_the_work, args=(working_dir, config_dir, gui, progress_indicator), kwargs=study_settings, cleanup_fun=gui.stop)
         proc_thread.start()
         gui.start()
         proc_thread.join()
     else:
-        do_the_work(working_dir, config_dir, None, **study_settings)
+        do_the_work(working_dir, config_dir, None, progress_indicator, **study_settings)
 
-def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: video_player.GUI, **study_settings):
+def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: video_player.GUI, progress_indicator: process_pool.JobProgress, **study_settings):
     has_gui = gui is not None
     sub_pixel_fac = 8   # for anti-aliased drawing
 
+    # progress indicator
+    if progress_indicator is None:
+        progress_indicator = process_pool.JobProgress(printer=lambda x: print(x))
+    progress_indicator.set_unit('frames')
+    progress_indicator.set_start_time_to_now()
+
     # get settings for the study
     study_config = config.read_study_config_with_overrides(config_dir, {config.OverrideLevel.Session: working_dir}, **study_settings)
     if not study_config.mapped_video_make_which:
@@ -229,8 +235,6 @@ def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: video_
         if sync_target_function is not None:
             pose_estimators[rec].register_extra_processing_fun('sync', *sync_target_function)
             pose_estimators[rec].show_extra_processing_output = study_config.mapped_video_show_sync_func_output
-        if study_config.sync_ref_recording and rec!=study_config.sync_ref_recording:
-            pose_estimators[rec].set_do_report_frames(False)
 
         if rec in study_config.mapped_video_make_which:
             pose_estimators[rec].set_visualize_on_frame(True)
@@ -292,6 +296,11 @@ def do_the_work(working_dir: pathlib.Path, config_dir: pathlib.Path, gui: video_
                 gui.set_show_action_tooltip(True, gui_window_ids[v])
                 gui.set_button_props_for_action(video_player.Action.Quit, 'Stop', tooltip='Interrupt (cut short) the video generation')
 
+        # prep progress indicator
+        total = videos_ts[lead_vid].get_last()[0]
+        progress_indicator.set_total(total)
+        progress_indicator.set_intervals(int(total/200), int(total/200))
+
         # open output video files
         for v in write_vids:
             # get which pixel format
@@ -444,6 +453,7 @@ def n_digit_timestamp(value_ms: float):
             for v in write_vids:
                 img = Image(plane_buffers=[frame[v].flatten().tobytes()], pix_fmt='bgr24', size=(frame[v].shape[1], frame[v].shape[0]))
                 vid_writer[v].write_frame(img=img, pts=frame_idx[lead_vid]/vid_info[lead_vid][2])
+            progress_indicator.update()
 
             # update gui, if any
             if has_gui:

src/gazeMapper/process/run_validation.py

@@ -8,12 +8,18 @@
 
 
 stopAllProcessing = False
-def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, **study_settings):
+def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path=None, progress_indicator: process_pool.JobProgress=None, **study_settings):
     working_dir = pathlib.Path(working_dir)
     if config_dir is None:
         config_dir = config.guess_config_dir(working_dir)
     config_dir  = pathlib.Path(config_dir)
 
+    # progress indicator
+    if progress_indicator is None:
+        progress_indicator = process_pool.JobProgress(printer=lambda x: print(x))
+    progress_indicator.set_unit('steps')
+    progress_indicator.set_start_time_to_now()
+
     # get settings for the study
     study_config = config.read_study_config_with_overrides(config_dir, {config.OverrideLevel.Session: working_dir.parent, config.OverrideLevel.Recording: working_dir}, **study_settings)
     if annotation.Event.Validate not in study_config.planes_per_episode:
@@ -28,6 +34,12 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, **st
     # get interval(s) coded to be analyzed, if any
     episodes = episode.list_to_marker_dict(episode.read_list_from_file(working_dir / naming.coding_file))[annotation.Event.Validate]
 
+    # prep progress indicator
+    total = len(planes)*(2+len(episodes)*3)
+    progress_indicator.set_total(total)
+    progress_indicator.set_intervals(int(total/200), int(total/200))
+    progress_indicator.update(n=0)  # ensure a complete hover text appears before first processing step is finished
+
     # per plane, run the glassesValidator steps
     for p in planes:
         plane_def = [pl for pl in study_config.planes if pl.name==p][0]
@@ -51,6 +63,7 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, **st
                                                     I2MC_settings_override=study_config.validate_I2MC_settings,
                                                     filename_stem=f'{naming.validation_prefix}{p}_fixations',
                                                     plot_limits=plot_limits)
+        progress_indicator.update()
 
         # assign intervals
         for idx,_ in enumerate(episodes):
@@ -70,6 +83,8 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, **st
                                               fix_file,
                                               do_global_shift=study_config.validate_do_global_shift,
                                               max_dist_fac=study_config.validate_max_dist_fac)
+            progress_indicator.update()
+
             # plot output
             assign_intervals.plot(selected_intervals,
                                   other_intervals,
@@ -81,11 +96,14 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, **st
                                   iteration=idx,
                                   background_image=background_image,
                                   plot_limits=plot_limits)
+            progress_indicator.update()
+
             # store output to file
             assign_intervals.to_tsv(selected_intervals,
                                     working_dir,
                                     filename_stem=f'{naming.validation_prefix}{p}_fixation_assignment',
                                     iteration=idx)
+            progress_indicator.update()
 
         compute_offsets.compute(working_dir/f'{naming.world_gaze_prefix}{p}.tsv',
                                 working_dir/f'{naming.plane_pose_prefix}{p}.tsv',
@@ -98,6 +116,7 @@ def run(working_dir: str|pathlib.Path, config_dir: str|pathlib.Path = None, **st
                                 dq_types=study_config.validate_dq_types,
                                 allow_dq_fallback=study_config.validate_allow_dq_fallback,
                                 include_data_loss=study_config.validate_include_data_loss)
+        progress_indicator.update()
 
     # update state
     session.update_action_states(working_dir, process.Action.VALIDATE, process_pool.State.Completed, study_config)