magscope.videoprocessing

Attributes

ValueTypeUI8
logger
_LOOKUP_Z_PROFILE_WARNING
_DEFAULT_TRACKING_OPTIONS

Classes

VideoProcessorManager	Abstract base class for processes in the MagScope
VideoWorker	Process objects represent activity that is run in a separate process

Module Contents

magscope.videoprocessing.ValueTypeUI8

magscope.videoprocessing.logger

magscope.videoprocessing._LOOKUP_Z_PROFILE_WARNING = 'lookup_z_profile_size_warning'

magscope.videoprocessing._DEFAULT_TRACKING_OPTIONS

class magscope.videoprocessing.VideoProcessorManager

Bases: magscope.processes.ManagerProcessBase

Abstract base class for processes in the MagScope

Subclass requirements: * Each subclass should have a unique name. * There should only be one instance of each subclass (singleton). * The class name is used for consistent inter-process identification.

_tasks: multiprocessing.queues.Queue | None = None

_n_workers: int | None = None

_workers: list[VideoWorker] = []

_gpu_lock: multiprocessing.synchronize.Lock

_profile_length_queue: multiprocessing.queues.Queue | None = None

_pending_profile_length_request = False

_warning_queue: multiprocessing.queues.Queue | None = None

_zlut_capture_complete_queue: multiprocessing.queues.Queue | None = None

_zlut_capture_earliest_timestamp: float | None = None

_zlut_capture_motor_z_value: float | None = None

_zlut_capture_remaining_profiles_per_bead: int | None = None

_zlut_capture_step_index: int | None = None

_zlut_frozen_bead_ids

_zlut_frozen_bead_rois

_zlut_profile_length_queue: multiprocessing.queues.Queue | None = None

_pending_zlut_profile_length_request = False

_lookup_z_warning_reported = False

_waiting_for_acquisition: bool | None = None

_save_profiles = False

_zlut_path: pathlib.Path | None

_zlut_metadata: dict[str, float | int] | None = None

_zlut = None

_tracking_options: dict

set_settings(settings: magscope.settings.MagScopeSettings)

update_tracking_options(value: dict)

setup()

do_main_loop()

_try_reserve_processing_stack() → bool

_release_reserved_processing_stack() → None

_stack_coordination_lock()

quit()

Shutdown the process (and ask the other processes to quit too).

load_zlut_file(filepath: str) → None

_load_default_zlut() → None

unload_zlut() → None

_clear_zlut_state() → None

_set_zlut_from_path(path: pathlib.Path) → None

static _extract_zlut_metadata(zlut_array: numpy.ndarray) → dict[str, float | int]

static _to_processing_array(zlut_array: numpy.ndarray)

_broadcast_zlut_metadata() → None

_notify_zlut_error(path: pathlib.Path, exc: Exception) → None

report_profile_length() → None

Arm a one-shot profile-length report for a future processed frame.

The request intentionally rides along with the normal worker task queue instead of probing the current VideoBuffer contents immediately. This keeps the result tied to video processed after the request arrives and ensures only one worker handles the request at a time via a normal task-local flag.

report_zlut_profile_length(bead_ids: tuple[int, Ellipsis] = (), bead_rois: tuple[tuple[int, int, int, int], Ellipsis] = ()) → None

_process_profile_length_reports() → None

Forward the first successful worker measurement back to the UI.

Workers only enqueue successful measurements, so leaving the pending flag armed causes later normal processing tasks to keep carrying the request until one succeeds.

_process_zlut_profile_length_reports() → None

clear_pending_zlut_profile_length_request() → None

arm_zlut_sweep_capture(step_index: int, motor_z_value: float, remaining_profiles_per_bead: int, earliest_timestamp: float, bead_ids: tuple[int, Ellipsis] = (), bead_rois: tuple[tuple[int, int, int, int], Ellipsis] = ()) → None

disarm_zlut_sweep_capture() → None

_process_zlut_capture_reports() → None

_add_task()

_set_zlut_frozen_rois(*, bead_ids: tuple[int, Ellipsis], bead_rois: tuple[tuple[int, int, int, int], Ellipsis]) → None

_should_use_frozen_zlut_rois() → bool

_process_worker_warnings() → None

script_wait_until_acquisition_on(value: bool)

_finish_waiting_when_ready()

class magscope.videoprocessing.VideoWorker(tasks: multiprocessing.queues.Queue, locks: dict[str, multiprocessing.synchronize.Lock], reserved_stacks: ValueTypeUI32, completed_stacks: ValueTypeUI64, busy_count: ValueTypeUI8, gpu_lock: multiprocessing.Lock, profile_length_queue: multiprocessing.queues.Queue | None, warning_queue: multiprocessing.queues.Queue | None, zlut_capture_complete_queue: multiprocessing.queues.Queue | None, zlut_profile_length_queue: multiprocessing.queues.Queue | None, live_profile_enabled: ValueTypeUI8, live_profile_bead: ValueTypeInt)

Bases: multiprocessing.Process

Process objects represent activity that is run in a separate process

The class is analogous to threading.Thread

_gpu_lock: multiprocessing.Lock

_tasks: multiprocessing.queues.Queue

_locks: dict[str, multiprocessing.synchronize.Lock]

_reserved_stacks: ValueTypeUI32

_completed_stacks: ValueTypeUI64

_busy_count: ValueTypeUI8

_profile_length_queue: multiprocessing.queues.Queue | None

_warning_queue: multiprocessing.queues.Queue | None

_zlut_capture_complete_queue: multiprocessing.queues.Queue | None

_zlut_profile_length_queue: multiprocessing.queues.Queue | None

_live_profile_enabled

_live_profile_bead

_video_buffer: magscope.datatypes.VideoBuffer | None = None

_tracks_buffer: magscope.datatypes.MatrixBuffer | None = None

_task_owes_reserved_stack = False

_zlut_sweep_dataset: magscope.datatypes.ZLUTSweepDataset | None = None

run()

Method to be run in sub-process; can be overridden in sub-class

_release_reserved_stack_if_pending() → None

_stack_coordination_lock()

_report_zlut_capture_task_failure(task: dict | None, exc: Exception) → None

_report_zlut_capture_task_retry(zlut_capture: dict | None) → None

process(kwargs)

_notify_lookup_profile_warning(warning_records: list[warnings.WarningMessage]) → None

_release_stack()