diff --git a/.github/workflows/testing.yaml b/.github/workflows/testing.yaml index e222947..67d8414 100644 --- a/.github/workflows/testing.yaml +++ b/.github/workflows/testing.yaml @@ -8,7 +8,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.9", "3.10", "3.11"] + python-version: ["3.10", "3.11"] steps: - uses: actions/checkout@v3 @@ -20,13 +20,13 @@ jobs: run: | python -m pip install --upgrade pip pip install flake8 pytest - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + pip install -e . - name: Lint with flake8 run: | # stop the build if there are Python syntax errors or undefined names flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - #- name: Test with pytest - # run: | - # pytest tests/tests \ No newline at end of file + - name: Test with pytest + run: | + pytest tests/test_telops.py \ No newline at end of file diff --git a/LDAQ/__init__.py b/LDAQ/__init__.py index d3ab2ea..2b981dc 100644 --- a/LDAQ/__init__.py +++ b/LDAQ/__init__.py @@ -9,4 +9,5 @@ from . import dewesoft from . import serial_communication from . import simulator +from . import telops diff --git a/LDAQ/telops/__init__.py b/LDAQ/telops/__init__.py new file mode 100644 index 0000000..468befd --- /dev/null +++ b/LDAQ/telops/__init__.py @@ -0,0 +1,3 @@ +from .acquisition import TelopsCamera + +_DOC_TelopsCamera = TelopsCamera.__doc__ diff --git a/LDAQ/telops/acquisition.py b/LDAQ/telops/acquisition.py new file mode 100644 index 0000000..ceecf6d --- /dev/null +++ b/LDAQ/telops/acquisition.py @@ -0,0 +1,375 @@ +import warnings + +import numpy as np + +from ..acquisition_base import BaseAcquisition + +try: + from pyTelops import Camera as _PyTelopsCamera +except ImportError: + _PyTelopsCamera = None + + +class TelopsCamera(BaseAcquisition): + """ + Acquisition class for Telops thermal cameras over GigE Vision. + + Uses the pyTelops driver, a pure-Python GigE Vision implementation + that does not require the Telops eBUS SDK. Tested against Telops + FAST-series MWIR cameras (e.g. FAST M3k). + + Installation: + + - Install pyTelops: ``pip install pyTelops`` + - No vendor SDK, no compiled extensions required. + + The plugin can either own its own :class:`pyTelops.Camera` instance + (default) or wrap a pre-configured one passed via ``camera=``. The + pre-configured pattern is useful when the camera needs lens-specific + calibration loading, NUC, or other one-time setup before acquisition. + + Examples + -------- + Standalone (plugin owns the camera):: + + import LDAQ + tel = LDAQ.telops.TelopsCamera(sample_rate=100.0, + integration_time=50.0) + with tel: + tel.run_acquisition(run_time=2.0) + t, data = tel.get_data() + + Pre-configured camera (with calibration block already loaded):: + + from pyTelops import Camera + cam = Camera() + cam.connect() + cam.calibration_load(lens="50mm", temp=25) + + tel = LDAQ.telops.TelopsCamera(sample_rate=100.0, camera=cam) + ni = LDAQ.national_instruments.NIAcquisition(...) + + ldaq = LDAQ.Core(acquisitions=[tel, ni]) + ldaq.run(measurement_duration=5.0) + + cam.disconnect() # user owns the camera, must clean up + """ + + def __init__(self, acquisition_name=None, sample_rate=None, + channel_name="thermal_field", + calibration_mode=None, + integration_time=None, + packet_delay=None, + camera=None): + """Initialize the Telops camera acquisition source. + + For an owned camera (``camera=None``, default), the plugin + applies sensible defaults (calibration_mode="RT", + sample_rate=100.0). For a user-provided camera (``camera=cam``), + the plugin respects the camera's existing configuration unless + the corresponding kwarg is explicitly passed. + + Args: + acquisition_name (str, optional): Name of this acquisition + source in the LDAQ Core. Defaults to "TelopsCamera". + + sample_rate (float, optional): Camera frame rate in Hz. + If ``None`` (default), the plugin uses 100 Hz when it + owns the camera, or whatever rate is currently set on + a user-provided camera. The actual achieved rate may + be clamped if the requested rate exceeds the camera's + max for the current resolution and integration time; + a warning is issued if the achieved rate differs by + more than 1%. Check :attr:`sample_rate` after + construction for the truthful value. + + channel_name (str, optional): Name of the thermal field + video channel. Defaults to "thermal_field". + + calibration_mode (str, optional): Camera calibration mode. + One of "RT" (radiometric temperature, Celsius float32), + "NUC" (uint16 NUC counts), "RAW" (uint16 raw counts), + "IBR", "IBI". If ``None`` (default), the plugin uses + "RT" when it owns the camera, or respects the existing + mode on a user-provided camera. + + packet_delay (int, optional): GVSP inter-packet delay in + camera timer ticks (8 ns each). Spreads the per-frame + packet burst over time so a slow or jittery + consumer/host process can't overflow the UDP receive + queue. ``1000`` = ~8 us between packets, safe up to + ~400 fps, eliminates most "packets unrecoverable" + warnings on live streaming. The value persists across + stream restarts. ``None`` (default) leaves whatever is + currently configured on the camera (usually 0 = no + delay). + + integration_time (float, optional): Integration time in + microseconds. If ``None`` (default), uses whatever is + currently set on the camera. + + camera (pyTelops.Camera, optional): A pre-configured and + connected pyTelops Camera instance. If ``None`` (default), + the plugin creates and manages its own Camera, connecting + in ``__init__`` and disconnecting in + ``terminate_data_source``. If a pre-connected Camera is + passed in, the user retains ownership and is responsible + for calling ``cam.disconnect()`` after acquisition. + + Raises: + ImportError: If pyTelops is not installed. + RuntimeError: If a user-provided camera is not connected. + """ + if _PyTelopsCamera is None: + raise ImportError( + "pyTelops is not installed. Install it with: " + "pip install pyTelops") + + super().__init__() + self.acquisition_name = ('TelopsCamera' if acquisition_name is None + else acquisition_name) + + # Internal flags; initialize early so terminate_data_source is + # safe to call even if __init__ raises mid-way. + self._owns_camera = (camera is None) + self.cam = None + self.camera_acq_started = False + self._acq_broken = False # set by read_data on persistent failure + + try: + # ---------------------------------------------------------- + # Camera ownership: create+connect, or wrap a pre-connected + # ---------------------------------------------------------- + if self._owns_camera: + self.cam = _PyTelopsCamera() + self.cam.connect() + else: + self.cam = camera + if not self.cam.is_connected: + raise RuntimeError( + "Pre-configured camera must be connected. Call " + "cam.connect() before passing it to TelopsCamera.") + + # ---------------------------------------------------------- + # Calibration mode: apply default only when plugin owns the + # camera and user didn't pass one. For user cameras with + # no kwarg, respect their pre-set configuration. + # ---------------------------------------------------------- + if calibration_mode is None and self._owns_camera: + calibration_mode = "RT" + if calibration_mode is not None: + self.cam.calibration_mode = calibration_mode + + # ---------------------------------------------------------- + # Integration time: only set if user explicitly requested + # ---------------------------------------------------------- + if integration_time is not None: + self.cam.integration_time = integration_time + + # ---------------------------------------------------------- + # Packet delay: spreads per-frame burst over time so a + # slow or jittery consumer/host process can keep up. + # Persists across stream restarts. + # ---------------------------------------------------------- + if packet_delay is not None: + self.cam.packet_delay = packet_delay + + # ---------------------------------------------------------- + # Sample rate: default 100 Hz only for owned cameras + # ---------------------------------------------------------- + if sample_rate is None and self._owns_camera: + sample_rate = 100.0 + if sample_rate is not None: + # The driver's frame_rate setter emits its own + # UserWarning when it clamps. Suppress it so only the + # plugin's richer RuntimeWarning fires for one clamp event. + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) + self.cam.frame_rate = sample_rate + self.sample_rate = self.cam.frame_rate + + # Warn if achieved rate differs significantly from requested + if sample_rate is not None and sample_rate > 0: + rel_err = abs(self.sample_rate - sample_rate) / sample_rate + if rel_err > 0.01: + warnings.warn( + f"Requested sample_rate {sample_rate:.1f} Hz was " + f"clamped by the camera to {self.sample_rate:.1f} Hz " + f"(max for current resolution and integration time). " + f"LDAQ timestamps will reflect the achieved rate.", + RuntimeWarning, stacklevel=2) + + # ---------------------------------------------------------- + # Output dtype: float32 for calibrated/temperature modes, + # uint16 for raw counts. Set BEFORE set_trigger() so the + # ring buffer is allocated with the correct dtype. + # ---------------------------------------------------------- + active_mode = self.cam.calibration_mode + # Handle both enum (real pyTelops) and string (test mocks) + mode_name = (active_mode.name if hasattr(active_mode, "name") + else str(active_mode)).upper() + # dtype assumption: NUC/RAW frames carry zero header + # coefficients, so the driver's convert step is a no-op cast + # and the data stays uint16. The float modes (RT, IBR, IBI) + # return float32. The astype in read_data relies on this. + if mode_name in ("RT", "IBR", "IBI"): + self.buffer_dtype = np.float32 + elif mode_name in ("NUC", "RAW", "RAW0"): + self.buffer_dtype = np.uint16 + else: + # Unknown mode; default to uint16 and warn + warnings.warn( + f"Unknown calibration mode '{mode_name}'. " + f"Defaulting buffer_dtype to uint16.", + RuntimeWarning, stacklevel=2) + self.buffer_dtype = np.uint16 + + # ---------------------------------------------------------- + # Channel setup: single video channel of shape (H, W). + # pyTelops returns (W, H); numpy convention is (rows, cols). + # ---------------------------------------------------------- + self._channel_names_video_init = [channel_name] + self._channel_shapes_video_init = [] # set in set_data_source + + self.set_data_source() + self.set_trigger(1e20, 0, duration=1.0) + + except Exception: + # Init failed; clean up so we don't leak the camera socket + # or leave the GVSP receiver running. + self._safe_cleanup() + raise + + def _safe_cleanup(self): + """Best-effort teardown of camera resources. Safe to call from + a partially-initialized state.""" + if self.camera_acq_started: + try: + self.cam.acquisition_stop() + except Exception: + pass + self.camera_acq_started = False + if self._owns_camera and self.cam is not None: + try: + self.cam.disconnect() + except Exception: + pass + + def set_data_source(self): + """Configure acquisition source. Idempotent, safe to call repeatedly. + + Reads the current camera resolution, populates the channel + shape, and starts continuous acquisition if not already running. + """ + # Populate channel shape from current camera resolution + if not self._channel_shapes_video_init: + w, h = self.cam.resolution + self._channel_shapes_video_init = [(h, w)] # numpy (rows, cols) + + # Start continuous acquisition if not already running + if not self.camera_acq_started: + self.cam.acquisition_start() + self.camera_acq_started = True + + super().set_data_source() + + def read_data(self): + """Pull the newest available frame from the running acquisition. + + Non-blocking: returns an empty array if no new frame is ready. + Uses ``cam.read_frame(latest=True)`` to **drain** the driver's + internal frame queue and return only the most recent frame; + older queued frames are discarded. This bounds end-to-end + latency when the consuming display/processing loop is slower + than the camera, so the live preview stays in sync with real + time instead of lagging further behind each second. + + Trade-off: if the consumer is slow, intermediate frames are + dropped. Because stale frames are discarded (latest=True), the + frame timestamps of a recorded measurement reflect the achieved + consumer/poll rate, not the camera frame rate, whenever the + consumer is slower than the camera. For faithful high-frame-rate + recorded capture, use the onboard-buffer workflow instead (see + example 014). + + Returns a 2D array of shape ``(n_samples, n_columns)`` where + ``n_samples`` is 0 or 1 and ``n_columns = H * W``. + + If the underlying camera raises ``RuntimeError`` (acquisition + stopped externally, e.g. network drop or forced disconnect), + a warning is issued the first time and subsequent reads return + empty without re-raising. LDAQ Core will then time out cleanly + rather than spin forever on a dead camera. + + Returns: + np.ndarray: Shape ``(0, H*W)`` if no frame ready, + ``(1, H*W)`` if a frame was pulled. + """ + shape = self.channel_shapes[ + self.channel_names_all.index(self.channel_names_video[0])] + n_pixels = shape[0] * shape[1] + + try: + # latest=True drains the queue and keeps only the newest + # frame, bounding live-display latency when the consumer + # is slower than the camera. + frame = self.cam.read_frame(timeout=0.0, latest=True) + except RuntimeError as e: + if not self._acq_broken: + warnings.warn( + f"TelopsCamera read_frame raised RuntimeError: {e}. " + f"Acquisition may have been stopped externally. " + f"Subsequent reads will return empty.", + RuntimeWarning, stacklevel=2) + self._acq_broken = True + return np.empty((0, n_pixels), dtype=self.buffer_dtype) + + if frame is None: + return np.empty((0, n_pixels), dtype=self.buffer_dtype) + + # Cast to expected dtype (no-copy if already correct) + return frame.reshape(1, n_pixels).astype(self.buffer_dtype, copy=False) + + def terminate_data_source(self): + """Stop continuous acquisition and clean up. + + If the plugin owns the camera, the camera is disconnected. + Otherwise only the acquisition is stopped; the camera remains + connected and the user retains full ownership. Safe to call + multiple times. + """ + if getattr(self, "camera_acq_started", False): + try: + self.cam.acquisition_stop() + except Exception: + pass + self.camera_acq_started = False + + if (getattr(self, "_owns_camera", False) + and getattr(self, "cam", None) is not None): + try: + if self.cam.is_connected: + self.cam.disconnect() + except Exception: + pass + + def get_sample_rate(self): + """Return the camera's sample (frame) rate in Hz.""" + return self.sample_rate + + def clear_buffer(self): + """Drain any pending frames from the camera buffer. + + Pulls frames non-blocking until the queue is empty, capped at + a reasonable upper bound to prevent infinite loops if the + producer outpaces the drain. + """ + if not self.camera_acq_started: + return + try: + for _ in range(10000): # cap to avoid infinite drain + frame = self.cam.read_frame(timeout=0.0) + if frame is None: + break + except RuntimeError: + pass diff --git a/README.rst b/README.rst index 402a26f..0748ed7 100644 --- a/README.rst +++ b/README.rst @@ -25,6 +25,8 @@ Key Features: - FLIR Cameras + - Telops Cameras + - Simulated hardware - 📊 **Advanced Data Visualization & Analysis**: LDAQ doesn’t just collect data; it helps you understand it. With built-in features like real-time signal visualization and Fast Fourier Transform (FFT) analysis, you can dive deep into your data for more insightful discoveries. @@ -155,5 +157,5 @@ What else can I do with LDAQ? - Apply functions to measured data in real-time visualization (see `visualization `_). - Add multiple acquisition and signal generation objects to ``LDAQ.Core`` (see `multiple sources `_). - Define a NI Task in your program and use it with ``LDAQ`` (see `NI Task `_). -- Currently the package supports a limited set of devices from National Instruments, Digilent, FLIR, Basler and devices using serial communication (see `supported devices `_). +- Currently the package supports a limited set of devices from National Instruments, Digilent, FLIR, Basler, Telops and devices using serial communication (see `supported devices `_). - Create your own acquisition class by overriding just few methods (see `custom acquisition `_). \ No newline at end of file diff --git a/docs/source/code.rst b/docs/source/code.rst index 6b63ad8..1b3e55a 100644 --- a/docs/source/code.rst +++ b/docs/source/code.rst @@ -6,7 +6,7 @@ Overview This section provides comprehensive documentation for the LDAQ code, designed to facilitate data acquisition, generation, and visualization across a variety of hardware platforms. The documentation is organized into several key sections, each focusing on a specific aspect of the LDAQ system. -The "Acquisition" section introduces the base acquisition class along with hardware-specific acquisition classes, detailing the methods and properties associated with data acquisition from various devices. These devices range from simulated environments and serial communications to specific hardware integrations like National Instruments, Digilent, FLIR thermal cameras, and Basler cameras. +The "Acquisition" section introduces the base acquisition class along with hardware-specific acquisition classes, detailing the methods and properties associated with data acquisition from various devices. These devices range from simulated environments and serial communications to specific hardware integrations like National Instruments, Digilent, FLIR thermal cameras, Basler cameras, and Telops thermal cameras. In the "Generation" section, the focus shifts to data generation. Here, the base generation class and various hardware-specific generation classes are documented, providing insights into how data can be generated and manipulated within the LDAQ framework. @@ -48,6 +48,9 @@ Hardware-Specific Acqusition Classes .. autoclass:: LDAQ.basler.BaslerCamera :members: +.. autoclass:: LDAQ.telops.TelopsCamera + :members: + Generation ---------- diff --git a/docs/source/supported_devices.rst b/docs/source/supported_devices.rst index 64dcb21..743c217 100644 --- a/docs/source/supported_devices.rst +++ b/docs/source/supported_devices.rst @@ -14,6 +14,8 @@ Acqusition - :class:`LDAQ.basler.BaslerCamera`: Based on pyPylon, any Basler Camera should work. +- :class:`LDAQ.telops.TelopsCamera`: Based on pyTelops (pure-Python GigE Vision, no vendor SDK), tested with Telops FAST M3k MWIR. Install the optional dependencies with ``pip install LDAQ[telops]`` (or install the underlying driver directly with ``pip install pyTelops``). + - :class:`LDAQ.simulator.SimulatedAcquisition`: Used to test the GUI without any hardware connected. Alternatively it can be used to track memory, CPU and disk usage. @@ -41,5 +43,9 @@ Hardware-Specific Installation Instructions :annotation: :noindex: +.. autodata:: LDAQ.telops.TelopsCamera + :annotation: + :noindex: + diff --git a/examples/013_acquisition_Telops_synchronized.ipynb b/examples/013_acquisition_Telops_synchronized.ipynb new file mode 100644 index 0000000..8d74edf --- /dev/null +++ b/examples/013_acquisition_Telops_synchronized.ipynb @@ -0,0 +1,328 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "57f7743b", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\", message=\"A module that was compiled using NumPy 1.x\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# pyTelops + LDAQ: Synchronized Multi-Sensor Acquisition\n", + "\n", + "**The Telops camera as a peer of NI DAQmx, FLIR, and Basler: one Python API, one synchronized acquisition.**\n", + "\n", + "This notebook shows pyTelops integrated into [LDAQ](https://github.com/ladisk/LDAQ), the Ladisk research group's open-source data acquisition framework. LDAQ already supports National Instruments DAQmx, Digilent, FLIR cameras, Basler cameras, Arduino/ESP serial, and DEWESoft. pyTelops adds a Python-native, SDK-free thermal source.\n", + "\n", + "A Telops camera runs alongside NI accelerometers, force sensors, and strain gauges in one synchronized Python pipeline." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Imports\n", + "\n", + "`LDAQ.telops.TelopsCamera` is a built-in submodule of LDAQ (mirrors `LDAQ.flir`, `LDAQ.basler`, `LDAQ.national_instruments`)." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4f2fae2d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import LDAQ;" + ] + }, + { + "cell_type": "markdown", + "id": "5b23cb86", + "metadata": {}, + "source": [ + "## 2. Source 1: Telops thermal camera\n", + "\n", + "One line of code creates the source. The plugin owns the camera lifecycle (connect -> configure -> start acquisition -> stop -> disconnect); LDAQ Core sees it as a regular `BaseAcquisition`." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "3cbbbc89", + "metadata": {}, + "outputs": [], + "source": [ + "telops_source = LDAQ.telops.TelopsCamera(\n", + " acquisition_name=\"thermal\",\n", + " sample_rate=5.0, # Hz, conservative for clean live preview\n", + " integration_time=50.0, # microseconds\n", + " calibration_mode=\"RT\", # radiometric temperature (Celsius)\n", + " packet_delay=2000, # ~16us between packets, spreads per-frame burst\n", + " # so Qt hiccups can't overflow the UDP queue\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "dc81d01c", + "metadata": {}, + "source": [ + "## 3. Source 2: NI DAQmx accelerometer\n", + "\n", + "This cell wires in a real National Instruments accelerometer via LDAQ's built-in `NIAcquisition` source. Two ways to configure it:\n", + "\n", + "- **Task from NI-MAX** (default below): reference an acquisition task you already set up in NI Measurement & Automation Explorer. Just pass its name as a string.\n", + "- **Programmatic task** (alternative): build the task in Python with `LDAQ.national_instruments.AITask` (from `nidaqwrapper`), add channels, and pass the `AITask` object as `task=` instead of a NI-MAX task name.\n", + "\n", + "Both approaches produce a source that plugs into `LDAQ.Core` the same way as the Telops camera" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "0786a540", + "metadata": {}, + "outputs": [], + "source": [ + "NI_TASK_NAME = \"AccelerationTask\"\n", + "\n", + "accel_source = LDAQ.national_instruments.NIAcquisition(\n", + " task=NI_TASK_NAME,\n", + " acquisition_name=\"accel\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ef1e0275", + "metadata": {}, + "source": [ + "## 4. Build the LDAQ Core with a live-preview GUI\n", + "\n", + "We build a `LDAQ.Visualization` object, attach it to the `Core`, and run. LDAQ opens a live-view window with:\n", + "\n", + "- **Live line plot** of the NI accelerometer channels, updating at the configured refresh rate (100 ms by default)\n", + "- **Live thermal image** of the Telops camera frames, CET-L17 colormap\n", + "- **`Start Measurement` button**, the record button, click it when you're ready to capture a synchronized run\n", + "- **`Stop` / `Close` / `Freeze` / `Full Screen` / `Toggle Legends` buttons**, standard live-view controls\n", + "\n", + "The whole thing is **three method calls**: `add_lines`, `add_image`, `Core(..., visualization=vis)`. No event loop setup and no custom widgets. The same pattern works for any combination of acquisition sources: NI + Telops here, but could be FLIR + Basler + Digilent + Dewesoft in the same window." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "fb26dec0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "closing app\n", + "closing app\n" + ] + } + ], + "source": [ + "# --- 1) Build the live-preview GUI -------------------------------\n", + "vis = LDAQ.Visualization(refresh_rate=100)\n", + "\n", + "# Live line plot, acceleration only (channel 1)\n", + "# AccelerationTask channels: [voltage=0, acceleration=1, force=2]\n", + "vis.add_lines(position=(0, 0), source=\"accel\", channels=[1])\n", + "vis.config_subplot((0, 0),\n", + " title=\"NI acceleration\",\n", + " t_span=2.0)\n", + "\n", + "# Live thermal image, Telops camera video channel\n", + "vis.add_image(source=\"thermal\", channel=\"thermal_field\",\n", + " colormap=\"CET-L17\")\n", + "\n", + "# --- 2) Build the Core with the visualization attached -----------\n", + "core = LDAQ.Core(\n", + " acquisitions=[telops_source, accel_source],\n", + " visualization=vis,\n", + ")\n", + "\n", + "# --- 3) Run ------------------------------------------------------\n", + "core.run(\n", + " measurement_duration=5.0,\n", + " autoclose=True,\n", + " autostart=False,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e7472c5d", + "metadata": {}, + "source": [ + "## 5. Extract the measurement\n", + "\n", + "`get_measurement_dict()` returns one dict per acquisition source containing time, data, channel names, and (for video sources) frame stacks." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "0b31f699", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Acceleration: 128000 samples over 5.00 s\n", + " (25600 Hz effective)\n", + "Thermal frames: 25 over 4.80 s\n", + " (5 fps effective)\n", + "Frame shape: (256, 320) (H, W)\n" + ] + } + ], + "source": [ + "meas = core.get_measurement_dict()\n", + "\n", + "# NI: pull only the acceleration channel (index 1)\n", + "acc_meas = meas[\"accel\"]\n", + "t_acc = acc_meas[\"time\"]\n", + "acceleration = acc_meas[\"data\"][:, 1]\n", + "\n", + "# Thermal video, one (n_frames, H, W) array per video channel\n", + "tel = meas[\"thermal\"]\n", + "t_tel = tel[\"time\"]\n", + "frames = tel[\"video\"][0]\n", + "\n", + "print(f\"Acceleration: {acceleration.shape[0]} samples over {t_acc[-1]:.2f} s\")\n", + "print(f\" ({acceleration.shape[0]/t_acc[-1]:.0f} Hz effective)\")\n", + "print(f\"Thermal frames: {frames.shape[0]} over {t_tel[-1]:.2f} s\")\n", + "print(f\" ({frames.shape[0]/t_tel[-1]:.0f} fps effective)\")\n", + "print(f\"Frame shape: {frames.shape[1:]} (H, W)\")" + ] + }, + { + "cell_type": "markdown", + "id": "2f9249f1", + "metadata": {}, + "source": [ + "## 6. Plot the synchronized timeline\n", + "\n", + "Both sources share **one common time axis**. The accelerometer waveform and the camera's mean temperature trace are plotted together." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7f65e91b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mean_temps = frames.mean(axis=(1, 2))\n", + "\n", + "fig, axes = plt.subplots(3, 1, figsize=(10, 10),\n", + " gridspec_kw={\"height_ratios\": [1.2, 1, 2]})\n", + "\n", + "# Acceleration (the structural response signal from the NI task)\n", + "axes[0].plot(t_acc, acceleration, lw=0.8, color=\"steelblue\")\n", + "axes[0].set_xlabel(\"time [s]\")\n", + "axes[0].set_ylabel(\"acceleration\")\n", + "axes[0].set_title(\"NI acceleration @ 25.6 kHz\")\n", + "axes[0].grid(alpha=0.3)\n", + "\n", + "# Thermal mean temperature over the same time window\n", + "axes[1].plot(t_tel, mean_temps, lw=1.5, color=\"crimson\", marker=\"o\", ms=3)\n", + "axes[1].set_xlabel(\"time [s]\")\n", + "axes[1].set_ylabel(\"mean T [°C]\")\n", + "axes[1].set_title(\n", + " f\"Telops thermal camera: {len(t_tel)} frames \"\n", + " f\"@ {len(t_tel)/t_tel[-1]:.0f} fps (synchronized to NI timeline)\"\n", + ")\n", + "axes[1].grid(alpha=0.3)\n", + "\n", + "# Sample thermal frame from the middle of the recording\n", + "mid_idx = len(t_tel) // 2\n", + "im = axes[2].imshow(frames[mid_idx], cmap=\"inferno\", aspect=\"equal\")\n", + "axes[2].set_title(f\"Telops frame at t = {t_tel[mid_idx]:.2f} s\")\n", + "axes[2].set_xlabel(\"pixel x\")\n", + "axes[2].set_ylabel(\"pixel y\")\n", + "plt.colorbar(im, ax=axes[2], label=\"°C\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34cf9897", + "metadata": {}, + "outputs": [], + "source": [ + "# The TelopsCamera plugin owns the camera lifecycle: it connects when the\n", + "# measurement starts and disconnects automatically when Core.run() returns.\n", + "# No manual teardown is needed here." + ] + }, + { + "cell_type": "markdown", + "id": "a6b1e587", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## Conclusion\n", + "\n", + "- **Two acquisition sources, one Python API.** TelopsCamera and the NI accelerometer were defined the same way, passed into the same `Core`, and executed in one call.\n", + "- **No vendor camera SDK.** The Telops source needs no eBUS, PySpin, or pypylon. It is pure Python and numpy. The NI accelerometer uses an NI-MAX acquisition task, which this demo requires.\n", + "- **Synchronized timestamps.** Both sources share a common time axis managed by LDAQ Core. Events can be cross-correlated.\n", + "- **Same code runs with FLIR or Basler cameras** in place of Telops. The `BaseAcquisition` contract is camera-agnostic.\n", + "\n", + "To run without any hardware, replace `LDAQ.national_instruments.NIAcquisition` with `LDAQ.simulator.SimulatedAcquisition`; the rest of the workflow is unchanged." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "openEOL_venv (3.11.9)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/014_acquisition_Telops_buffered_synchronized.ipynb b/examples/014_acquisition_Telops_buffered_synchronized.ipynb new file mode 100644 index 0000000..4c715a8 --- /dev/null +++ b/examples/014_acquisition_Telops_buffered_synchronized.ipynb @@ -0,0 +1,380 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c01", + "metadata": {}, + "source": [ + "# LDAQ + pyTelops: buffered, software-triggered synchronized capture\n", + "\n", + "Capture a NI-DAQ accelerometer and a Telops thermal camera together, with the\n", + "camera recording to its onboard 16 GB buffer at full frame rate instead of\n", + "streaming live. A single software trigger starts both, and the small residual\n", + "offset is measured so it can be removed in post-processing.\n", + "\n", + "**Why buffered instead of live streaming** (as in example 013):\n", + "\n", + "- The camera records every frame to internal memory at full sensor speed,\n", + " decoupled from the host and the network. Nothing on the PC side can drop\n", + " frames or add latency during the capture.\n", + "- The accelerometer runs through LDAQ as usual.\n", + "- Because the camera is not a live LDAQ source here, it is driven directly with\n", + " the pyTelops `Camera` API, and the frames are downloaded after the capture.\n", + "\n", + "**Synchronization.** The start trigger is fired in software: the camera MOI\n", + "(moment of interest) and the LDAQ trigger are issued back to back, bracketed by\n", + "`perf_counter` timestamps. Expect a residual start offset of roughly 1 to 2 ms\n", + "(GigE command latency plus the LDAQ trigger granularity), plus a small drift\n", + "between the two independent clocks over the record. For tighter synchronization,\n", + "see the note at the end." + ] + }, + { + "cell_type": "code", + "id": "c02", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\", message=\"A module that was compiled using NumPy 1.x\")" + ] + }, + { + "cell_type": "markdown", + "id": "c03", + "metadata": {}, + "source": [ + "## 1. Parameters\n", + "\n", + "Everything you might tune lives here." + ] + }, + { + "cell_type": "code", + "id": "c04", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "import time\n", + "import threading\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import LDAQ\n", + "from pyTelops import Camera\n", + "\n", + "# --- Camera (onboard buffer) ---\n", + "FPS = 1000.0 # camera frame rate [Hz]\n", + "INTEGRATION_TIME = 50.0 # integration (exposure) time [us]\n", + "CALIBRATION_MODE = \"RT\" # radiometric temperature -> float32 Celsius\n", + "CAPTURE_S = 2.0 # post-trigger capture duration [s]\n", + "PRE_MOI = 100 # frames recorded before the trigger (pre-trigger margin)\n", + "\n", + "# --- Accelerometer (NI DAQ via LDAQ) ---\n", + "NI_TASK = \"AccelerationTask\" # NI MAX task name, or an LDAQ AITask object\n", + "ACCEL_CHANNEL = 1 # channel index to plot (task-dependent)\n", + "\n", + "N_POST = round(FPS * CAPTURE_S) # frames recorded after the trigger\n", + "N_FRAMES = N_POST + PRE_MOI # total frames per buffer sequence\n", + "\n", + "print(f\"Camera: {N_FRAMES} frames at {FPS:.0f} fps \"\n", + " f\"({PRE_MOI} pre-trigger + {N_POST} post-trigger = {CAPTURE_S:.2f} s)\")" + ] + }, + { + "cell_type": "markdown", + "id": "c05", + "metadata": {}, + "source": [ + "## 2. Connect and configure the camera (buffer mode)\n", + "\n", + "Set the acquisition parameters, then configure and arm the onboard buffer with a\n", + "software MOI source. After `buffer_arm()` the camera continuously fills a rolling\n", + "pre-trigger buffer and waits for the MOI; the delay between arming here and\n", + "firing the trigger later does not matter." + ] + }, + { + "cell_type": "code", + "id": "c06", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "cam = Camera()\n", + "cam.connect()\n", + "\n", + "cam.calibration_mode = CALIBRATION_MODE\n", + "cam.integration_time = INTEGRATION_TIME\n", + "cam.frame_rate = FPS\n", + "FPS_ACTUAL = cam.frame_rate # the camera may clamp the requested rate\n", + "print(f\"Connected. Frame rate {FPS_ACTUAL:.1f} Hz (max {cam.frame_rate_max:.1f} Hz)\")\n", + "\n", + "cam.buffer_configure(\n", + " n_sequences=1,\n", + " frames_per_seq=N_FRAMES,\n", + " pre_moi=PRE_MOI,\n", + " moi_source=\"software\",\n", + ")\n", + "cam.buffer_arm()\n", + "print(cam.buffer_info())" + ] + }, + { + "cell_type": "markdown", + "id": "c07", + "metadata": {}, + "source": [ + "## 3. Build the accelerometer source and launch LDAQ\n", + "\n", + "`Core.run()` blocks while it waits for a trigger, so it runs in a background\n", + "thread. We then wait until the source reports ready and fire the trigger from the\n", + "main thread. `autostart=False` keeps it from starting on its own; `hotkeys=False`\n", + "because the trigger is issued programmatically." + ] + }, + { + "cell_type": "code", + "id": "c08", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": "accel = LDAQ.national_instruments.NIAcquisition(\n task=NI_TASK, # NI MAX task name, or an AITask object\n acquisition_name=\"accel\",\n)\ncore = LDAQ.Core(acquisitions=[accel])\n\ncore_thread = threading.Thread(\n target=core.run,\n kwargs=dict(\n measurement_duration=CAPTURE_S,\n autoclose=True,\n autostart=False,\n hotkeys=False,\n verbose=0,\n ),\n daemon=True,\n)\ncore_thread.start()\n\n# Wait until the accelerometer source is armed and ready for the trigger.\n# Break early if the worker thread dies or signals a failure during setup,\n# instead of waiting out the full timeout on a misleading \"not ready\" message.\nt_wait = time.perf_counter()\nwhile not all(a.is_ready for a in core.acquisitions):\n worker_failed = not core_thread.is_alive() or (\n getattr(core, \"stop_event\", None) is not None and core.stop_event.is_set()\n )\n if worker_failed:\n raise RuntimeError(\n \"LDAQ setup failed before the source became ready. Check the \"\n \"traceback printed above - this is usually a wrong task name or \"\n \"missing hardware.\"\n )\n if time.perf_counter() - t_wait > 15.0:\n raise TimeoutError(\"LDAQ source did not become ready within 15 s\")\n time.sleep(0.005)\ntime.sleep(0.2) # settle\nprint(\"Accelerometer armed and ready.\")" + }, + { + "cell_type": "markdown", + "id": "c09", + "metadata": {}, + "source": [ + "## 4. Fire the synchronized software trigger\n", + "\n", + "Both triggers are fired back to back. The camera MOI marks camera `t = 0`; the\n", + "LDAQ global trigger marks accelerometer `t = 0`. The gap between the two host\n", + "calls (`host_offset`) is the correction applied to the camera timeline later." + ] + }, + { + "cell_type": "code", + "id": "c10", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "t_cam = time.perf_counter()\n", + "cam.buffer_fire_moi()\n", + "t_acc = time.perf_counter()\n", + "core.start_acquisition()\n", + "t_after = time.perf_counter()\n", + "\n", + "host_offset = t_acc - t_cam # camera was triggered this many seconds before accel\n", + "print(f\"host_offset (camera leads accel): {host_offset * 1e3:.2f} ms\")\n", + "print(f\" MOI call {(t_acc - t_cam) * 1e3:.2f} ms, \"\n", + " f\"trigger call {(t_after - t_acc) * 1e3:.2f} ms\")" + ] + }, + { + "cell_type": "markdown", + "id": "c11", + "metadata": {}, + "source": [ + "## 5. Wait for the buffer, then download\n", + "\n", + "Join the LDAQ thread (it returns after its `CAPTURE_S` window), wait for the\n", + "camera to finish writing the sequence, and download the frames from the onboard\n", + "buffer." + ] + }, + { + "cell_type": "code", + "id": "c12", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": "core_thread.join(timeout=CAPTURE_S + 30.0)\nif core_thread.is_alive():\n raise TimeoutError(\"LDAQ measurement did not finish in time\")\n\nstatus = cam.buffer_wait(timeout=60.0)\nprint(f\"Buffer status: {status.name}, {cam.buffer_recorded_frames(0)} frames recorded\")\n\nframes = cam.buffer_download(sequence=0, verbose=False) # (N, H, W) float32 Celsius in RT mode\nprint(f\"Downloaded frames: {frames.shape}, {frames.dtype}\")" + }, + { + "cell_type": "markdown", + "id": "c13", + "metadata": {}, + "source": [ + "## 6. Retrieve the accelerometer data\n", + "\n", + "The accelerometer time vector already has `t = 0` at the trigger." + ] + }, + { + "cell_type": "code", + "id": "c14", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "meas = core.get_measurement_dict()\n", + "acc = meas[\"accel\"]\n", + "\n", + "t_acc_data = acc[\"time\"]\n", + "accel_signal = acc[\"data\"][:, ACCEL_CHANNEL]\n", + "accel_rate = acc[\"sample_rate\"]\n", + "print(f\"Accelerometer: {accel_signal.shape[0]} samples at {accel_rate:.0f} Hz \"\n", + " f\"({t_acc_data[-1]:.2f} s)\")" + ] + }, + { + "cell_type": "markdown", + "id": "c15", + "metadata": {}, + "source": [ + "## 7. Align the two sources on a common timeline\n", + "\n", + "The MOI frame sits at index `PRE_MOI` in the downloaded stack and is camera\n", + "`t = 0`. Scale the frame index by the camera's actual frame rate, then shift by\n", + "the measured `host_offset` so the camera timeline matches the accelerometer one." + ] + }, + { + "cell_type": "code", + "id": "c16", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "n_frames = frames.shape[0]\n", + "t_frames = (np.arange(n_frames) - PRE_MOI) / FPS_ACTUAL - host_offset\n", + "\n", + "mean_temps = frames.mean(axis=(1, 2))\n", + "print(f\"Frame timeline: {t_frames[0]:.3f} s to {t_frames[-1]:.3f} s \"\n", + " f\"(MOI at index {PRE_MOI})\")" + ] + }, + { + "cell_type": "markdown", + "id": "c17", + "metadata": {}, + "source": [ + "## 8. Plot the synchronized timeline" + ] + }, + { + "cell_type": "code", + "id": "c18", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(3, 1, figsize=(10, 10),\n", + " gridspec_kw={\"height_ratios\": [1.2, 1, 2]})\n", + "\n", + "axes[0].plot(t_acc_data, accel_signal, lw=0.7, color=\"steelblue\")\n", + "axes[0].axvline(0.0, color=\"k\", ls=\"--\", lw=1, alpha=0.6)\n", + "axes[0].set(xlabel=\"time [s]\", ylabel=\"acceleration\",\n", + " title=f\"NI accelerometer @ {accel_rate:.0f} Hz\")\n", + "axes[0].grid(alpha=0.3)\n", + "\n", + "axes[1].plot(t_frames, mean_temps, lw=1.3, color=\"crimson\", marker=\"o\", ms=2)\n", + "axes[1].axvline(0.0, color=\"k\", ls=\"--\", lw=1, alpha=0.6)\n", + "axes[1].set(xlabel=\"time [s]\", ylabel=\"mean T [deg C]\",\n", + " title=f\"Telops buffered capture: {n_frames} frames @ {FPS_ACTUAL:.0f} fps\")\n", + "axes[1].grid(alpha=0.3)\n", + "\n", + "idx0 = int(np.argmin(np.abs(t_frames))) # frame nearest the trigger\n", + "im = axes[2].imshow(frames[idx0], cmap=\"inferno\", aspect=\"auto\")\n", + "axes[2].set(title=f\"Frame nearest t=0 (index {idx0}, t={t_frames[idx0]:.3f} s)\",\n", + " xlabel=\"pixel x\", ylabel=\"pixel y\")\n", + "plt.colorbar(im, ax=axes[2], label=\"deg C\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c19", + "metadata": {}, + "source": [ + "## 9. Save the synchronized capture" + ] + }, + { + "cell_type": "code", + "id": "c20", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "out_path = \"buffered_sync_capture.npz\"\n", + "np.savez_compressed(\n", + " out_path,\n", + " frames=frames,\n", + " frame_time=t_frames,\n", + " accel_time=t_acc_data,\n", + " accel_signal=accel_signal,\n", + " fps_actual=FPS_ACTUAL,\n", + " accel_rate=accel_rate,\n", + " pre_moi=PRE_MOI,\n", + " host_offset=host_offset,\n", + ")\n", + "print(f\"Saved {out_path}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c21", + "metadata": {}, + "source": [ + "## 10. Clean up" + ] + }, + { + "cell_type": "code", + "id": "c22", + "metadata": {}, + "execution_count": null, + "outputs": [], + "source": [ + "cam.buffer_clear()\n", + "cam.disconnect()\n", + "print(f\"Camera connected: {cam.is_connected}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c23", + "metadata": {}, + "source": [ + "## Notes on synchronization\n", + "\n", + "This example uses a software trigger: the camera MOI and the LDAQ trigger are\n", + "fired back to back and the residual offset is measured (`host_offset`) and\n", + "removed when building the frame timeline. The realistic residual is about 1 to\n", + "2 ms, dominated by GigE command latency and the LDAQ trigger granularity, plus a\n", + "small drift between the two independent clocks over the record.\n", + "\n", + "To tighten synchronization toward tens of microseconds, use a shared hardware\n", + "trigger instead:\n", + "\n", + "- Wire a single electrical trigger pulse to the camera BNC trigger input and to\n", + " a spare NI-DAQ input channel.\n", + "- Configure the camera with `configure_trigger(source=\"external\")` and\n", + " `buffer_configure(moi_source=\"external\")`.\n", + "- The shared edge then appears in the accelerometer data (sample-accurate\n", + " `t = 0`) and starts the camera at the same instant." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index ad6365c..6ae68eb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -74,6 +74,9 @@ ni = [ "nidaqwrapper>=0.1.0", "nidaqmx>=0.8.0", ] +telops = [ + "pyTelops>=0.2.2", +] [project.urls] homepage = "https://github.com/ladisk/LDAQ" diff --git a/tests/test_telops.py b/tests/test_telops.py new file mode 100644 index 0000000..64ecaea --- /dev/null +++ b/tests/test_telops.py @@ -0,0 +1,425 @@ +"""Tests for the LDAQ TelopsCamera plugin (no hardware required). + +These tests mock the pyTelops Camera class to verify the plugin's +wiring, lifecycle, and read_data contract without touching real +hardware. Hardware-dependent tests are marked separately and skipped +in the default run. +""" + +from unittest.mock import MagicMock, patch + +import numpy as np +import pytest + + +def _make_fake_pytelops_camera(width=64, height=64, + cal_mode_name="RT", + frame_rate=100.0): + """Build a MagicMock that quacks like a pyTelops Camera.""" + cam = MagicMock() + cam.is_connected = True + cam.is_acquiring = False + + # Properties (settable + readable) + cam.resolution = (width, height) + cam.frame_rate = frame_rate + cam.integration_time = 50.0 + + # calibration_mode returns an object with .name (mimics IntEnum) + cal_mode = MagicMock() + cal_mode.name = cal_mode_name + cam.calibration_mode = cal_mode + + # read_frame returns float32 (H, W) frames in RT mode + fake_frame = np.full((height, width), 25.0, dtype=np.float32) + cam.read_frame.return_value = fake_frame + + return cam + + +@pytest.fixture +def fake_camera(): + return _make_fake_pytelops_camera() + + +@pytest.fixture +def telops_module(): + """Patch pyTelops in the plugin namespace and return the module. + + Uses ``create=True`` so the test runs even if pyTelops is not + installed (in which case the plugin's ``try/except ImportError`` + leaves ``_PyTelopsCamera`` undefined). + """ + import LDAQ.telops.acquisition as mod + with patch.object(mod, "_PyTelopsCamera", create=True) as mock_cls: + mock_cls.side_effect = lambda *a, **kw: _make_fake_pytelops_camera() + yield mod + + +class TestTelopsCameraConstruction: + """Constructor wiring - owned camera, user-provided camera.""" + + def test_owned_camera_default(self, telops_module): + tel = telops_module.TelopsCamera() + assert tel.acquisition_name == "TelopsCamera" + assert tel._owns_camera is True + assert tel.cam.is_connected + assert tel.sample_rate == 100.0 # default + assert tel.buffer_dtype == np.float32 # RT mode + assert tel.camera_acq_started is True + tel.cam.acquisition_start.assert_called_once() + + def test_user_provided_camera(self, telops_module): + cam = _make_fake_pytelops_camera() + tel = telops_module.TelopsCamera(camera=cam) + assert tel._owns_camera is False + assert tel.cam is cam + cam.acquisition_start.assert_called_once() + + def test_user_camera_must_be_connected(self, telops_module): + cam = _make_fake_pytelops_camera() + cam.is_connected = False + with pytest.raises(RuntimeError, match="must be connected"): + telops_module.TelopsCamera(camera=cam) + + def test_custom_acquisition_name(self, telops_module): + tel = telops_module.TelopsCamera(acquisition_name="thermal_top") + assert tel.acquisition_name == "thermal_top" + + def test_sample_rate_set_and_read_back(self, telops_module): + # Plugin should set frame_rate on the camera, then read back + # the actual achieved value. With a plain MagicMock the read-back + # equals the set value - real pyTelops would clamp to the max + # achievable for the current resolution and integration time. + tel = telops_module.TelopsCamera(sample_rate=250.0) + assert tel.sample_rate == 250.0 + + def test_sample_rate_none_uses_camera_default(self, telops_module): + cam = _make_fake_pytelops_camera(frame_rate=42.0) + tel = telops_module.TelopsCamera(sample_rate=None, camera=cam) + assert tel.sample_rate == 42.0 + + def test_integration_time_passed_through(self, telops_module): + cam = _make_fake_pytelops_camera() + tel = telops_module.TelopsCamera(integration_time=25.0, camera=cam) + # The plugin should have set integration_time on the camera + assert cam.integration_time == 25.0 + + def test_packet_delay_passed_through(self, telops_module): + cam = _make_fake_pytelops_camera() + tel = telops_module.TelopsCamera(packet_delay=1000, camera=cam) + # The plugin should have set packet_delay on the camera + assert cam.packet_delay == 1000 + + def test_packet_delay_none_leaves_camera_untouched(self, telops_module): + """Omitting packet_delay must NOT touch the camera's setting.""" + cam = _make_fake_pytelops_camera() + cam.packet_delay = 7 # pre-existing value on the camera + tel = telops_module.TelopsCamera(camera=cam) # no packet_delay kwarg + assert cam.packet_delay == 7 + + def test_buffer_dtype_uint16_for_raw_modes(self, telops_module): + cam = _make_fake_pytelops_camera(cal_mode_name="NUC") + tel = telops_module.TelopsCamera(camera=cam, calibration_mode=None) + assert tel.buffer_dtype == np.uint16 + + def test_buffer_dtype_float32_for_rt_mode(self, telops_module): + cam = _make_fake_pytelops_camera(cal_mode_name="RT") + tel = telops_module.TelopsCamera(camera=cam, calibration_mode=None) + assert tel.buffer_dtype == np.float32 + + def test_buffer_dtype_uint16_for_raw0(self, telops_module): + cam = _make_fake_pytelops_camera(cal_mode_name="RAW0") + tel = telops_module.TelopsCamera(camera=cam, calibration_mode=None) + assert tel.buffer_dtype == np.uint16 + + def test_unknown_calibration_mode_warns(self, telops_module): + cam = _make_fake_pytelops_camera(cal_mode_name="WEIRD_MODE") + with pytest.warns(RuntimeWarning, match="Unknown calibration mode"): + tel = telops_module.TelopsCamera(camera=cam, calibration_mode=None) + # Falls back to uint16 + assert tel.buffer_dtype == np.uint16 + + def test_calibration_mode_string_fallback(self, telops_module): + """Real pyTelops returns an enum with .name; tests use a string. + The plugin must handle both via the hasattr fallback.""" + cam = _make_fake_pytelops_camera() + cam.calibration_mode = "RT" # plain string, no .name attribute + tel = telops_module.TelopsCamera(camera=cam, calibration_mode=None) + assert tel.buffer_dtype == np.float32 + + def test_calibration_mode_none_respects_user_camera(self, telops_module): + """When camera= is provided and calibration_mode is None, + the plugin must NOT touch the camera's existing mode.""" + cam = _make_fake_pytelops_camera(cal_mode_name="NUC") + original_mode = cam.calibration_mode # save reference + tel = telops_module.TelopsCamera(camera=cam, calibration_mode=None) + # The setter was NOT called - calibration_mode is still the + # original MagicMock object we pre-set. + assert cam.calibration_mode is original_mode + + def test_calibration_mode_default_only_for_owned_camera(self, telops_module): + """For a user-provided camera with no kwarg, RT must NOT be + the silent default.""" + cam = _make_fake_pytelops_camera(cal_mode_name="NUC") + original_mode = cam.calibration_mode + tel = telops_module.TelopsCamera(camera=cam) # no calibration_mode kwarg + # User camera + no kwarg → respect existing mode + assert cam.calibration_mode is original_mode + + def test_owned_camera_default_calibration_is_rt(self, telops_module): + """For an owned camera with no kwarg, RT IS the default.""" + tel = telops_module.TelopsCamera() + # Plugin set calibration_mode = "RT" on the owned camera + assert tel.cam.calibration_mode == "RT" + + def test_sample_rate_default_only_for_owned_camera(self, telops_module): + """User-provided camera with no sample_rate kwarg keeps existing rate.""" + cam = _make_fake_pytelops_camera(frame_rate=42.5) + tel = telops_module.TelopsCamera(camera=cam) # no sample_rate + assert tel.sample_rate == 42.5 # not 100.0 (the owned-camera default) + + def test_sample_rate_clamp_warning(self, telops_module): + """If the camera clamps the requested rate, a warning should fire.""" + # Use a small fake class so the property semantics are predictable. + class ClampingCam: + is_connected = True + is_acquiring = False + resolution = (64, 64) + integration_time = 50.0 + calibration_mode = type("M", (), {"name": "RT"})() + _achieved = 50.0 # clamped value + @property + def frame_rate(self): + return self._achieved + @frame_rate.setter + def frame_rate(self, value): + pass # silently clamp to _achieved + def acquisition_start(self): pass + def acquisition_stop(self): pass + def read_frame(self, timeout=0.0): + return np.zeros((64, 64), dtype=np.float32) + def disconnect(self): pass + + with pytest.warns(RuntimeWarning, match="clamped"): + telops_module.TelopsCamera(camera=ClampingCam(), sample_rate=200.0) + + def test_init_failure_cleans_up_owned_camera(self, telops_module): + """If __init__ raises after creating+connecting the owned camera, + the camera must be disconnected (no socket leak).""" + cleanup_seen = {"disconnected": False, "acq_stopped": False} + + class FailingCam: + is_connected = False + is_acquiring = False + resolution = (64, 64) + frame_rate = 100.0 + integration_time = 50.0 + calibration_mode = type("M", (), {"name": "RT"})() + def connect(self): + self.is_connected = True + def disconnect(self): + self.is_connected = False + cleanup_seen["disconnected"] = True + def acquisition_start(self): + raise RuntimeError("simulated acquisition_start failure") + def acquisition_stop(self): + cleanup_seen["acq_stopped"] = True + def read_frame(self, timeout=0.0): + return None + + telops_module._PyTelopsCamera.side_effect = lambda: FailingCam() + with pytest.raises(RuntimeError, match="simulated"): + telops_module.TelopsCamera() + assert cleanup_seen["disconnected"], ( + "Owned camera must be disconnected when __init__ raises " + "after connect()") + # acquisition_start raised before camera_acq_started flipped True, + # so cleanup must NOT call acquisition_stop on this path. + assert cleanup_seen["acq_stopped"] is False + + def test_init_failure_after_acq_start_stops_and_disconnects( + self, telops_module): + """If __init__ raises AFTER acquisition_start succeeds (owned + camera), cleanup must stop acquisition AND disconnect.""" + cam = _make_fake_pytelops_camera() + telops_module._PyTelopsCamera.side_effect = lambda: cam + + # acquisition_start succeeds (sets camera_acq_started True), then a + # later __init__ step raises. set_trigger runs right after + # set_data_source (which calls acquisition_start), so patching it to + # raise is the only path that reaches the acquisition_stop branch. + def boom(*a, **kw): + raise RuntimeError("simulated post-acquisition_start failure") + + with patch.object(telops_module.TelopsCamera, "set_trigger", boom): + with pytest.raises(RuntimeError, match="simulated"): + telops_module.TelopsCamera() + + cam.acquisition_start.assert_called_once() + cam.acquisition_stop.assert_called_once() + cam.disconnect.assert_called_once() + + +class TestTelopsCameraDataFlow: + """read_data shape, dtype, and empty-call behavior.""" + + def test_channel_shape_matches_resolution(self, telops_module): + cam = _make_fake_pytelops_camera(width=128, height=64) + tel = telops_module.TelopsCamera(camera=cam) + # Channel shape is (H, W) - numpy convention + assert tel._channel_shapes_video_init == [(64, 128)] + + def test_read_data_returns_one_frame(self, telops_module): + cam = _make_fake_pytelops_camera(width=8, height=4) + tel = telops_module.TelopsCamera(camera=cam) + result = tel.read_data() + assert result.shape == (1, 32) # (1 sample, H*W = 4*8) + assert result.dtype == np.float32 + assert (result == 25.0).all() + # Live-latency contract: read_data must drain to the newest frame + # via the non-blocking latest=True call. + cam.read_frame.assert_called_with(timeout=0.0, latest=True) + + def test_read_data_returns_empty_when_no_frame(self, telops_module): + cam = _make_fake_pytelops_camera(width=8, height=4) + cam.read_frame.return_value = None + tel = telops_module.TelopsCamera(camera=cam) + result = tel.read_data() + assert result.shape == (0, 32) + assert result.dtype == np.float32 + + def test_read_data_handles_runtime_error_gracefully(self, telops_module): + """If acquisition was stopped externally, read_data returns empty.""" + cam = _make_fake_pytelops_camera(width=8, height=4) + cam.read_frame.side_effect = RuntimeError("acquisition not active") + tel = telops_module.TelopsCamera(camera=cam) + result = tel.read_data() + assert result.shape == (0, 32) + + def test_get_sample_rate(self, telops_module): + tel = telops_module.TelopsCamera() + assert tel.get_sample_rate() == tel.sample_rate + + def test_read_data_uint16_dtype_for_raw_modes(self, telops_module): + """In NUC mode the plugin must produce uint16 frames.""" + cam = _make_fake_pytelops_camera(width=8, height=4, + cal_mode_name="NUC") + fake_uint16 = np.full((4, 8), 1234, dtype=np.uint16) + cam.read_frame.return_value = fake_uint16 + tel = telops_module.TelopsCamera(camera=cam, calibration_mode=None) + result = tel.read_data() + assert result.shape == (1, 32) + assert result.dtype == np.uint16 + assert (result == 1234).all() + + def test_clear_buffer_drains_until_empty(self, telops_module): + cam = _make_fake_pytelops_camera(width=8, height=4) + tel = telops_module.TelopsCamera(camera=cam) + # Reset after constructor so we count only clear_buffer calls + cam.read_frame.reset_mock() + fake = np.zeros((4, 8), dtype=np.float32) + cam.read_frame.side_effect = [fake, fake, fake, None] + tel.clear_buffer() + # Drain pulled 3 frames and then saw None, terminating the loop. + # The 4th call (returning None) is what breaks the loop, so the + # drain makes exactly 4 calls: 3 frames + 1 terminating None. + assert cam.read_frame.call_count == 4 + + def test_clear_buffer_caps_at_10000(self, telops_module): + """A producer that never empties must not loop forever: the + drain is bounded at 10000 iterations.""" + cam = _make_fake_pytelops_camera(width=8, height=4) + tel = telops_module.TelopsCamera(camera=cam) + # Acquisition is started by the constructor, so clear_buffer drains. + assert tel.camera_acq_started is True + # Reset after constructor so we count only clear_buffer calls. + cam.read_frame.reset_mock() + # Always return a frame (no None, no finite side_effect): the only + # thing that can end the loop is the iteration cap. + cam.read_frame.side_effect = None + cam.read_frame.return_value = np.zeros((4, 8), dtype=np.float32) + tel.clear_buffer() + assert cam.read_frame.call_count == 10000 + + def test_clear_buffer_noop_when_not_started(self, telops_module): + """After terminate, clear_buffer must not call read_frame.""" + cam = _make_fake_pytelops_camera() + tel = telops_module.TelopsCamera(camera=cam) + tel.terminate_data_source() + cam.read_frame.reset_mock() + tel.clear_buffer() + cam.read_frame.assert_not_called() + + def test_clear_buffer_swallows_runtime_error(self, telops_module): + """clear_buffer must not propagate RuntimeError from a dead camera.""" + cam = _make_fake_pytelops_camera() + cam.read_frame.side_effect = RuntimeError("acquisition not active") + tel = telops_module.TelopsCamera(camera=cam) + # Must not raise + tel.clear_buffer() + + +class TestTelopsCameraLifecycle: + """Lifecycle: set_data_source, terminate_data_source, ownership.""" + + def test_set_data_source_idempotent(self, telops_module): + tel = telops_module.TelopsCamera() + # Constructor already called set_data_source once + n_calls_before = tel.cam.acquisition_start.call_count + tel.set_data_source() + tel.set_data_source() + # No extra acquisition_start calls + assert tel.cam.acquisition_start.call_count == n_calls_before + + def test_terminate_disconnects_owned_camera(self, telops_module): + tel = telops_module.TelopsCamera() + owned_cam = tel.cam + tel.terminate_data_source() + owned_cam.acquisition_stop.assert_called_once() + owned_cam.disconnect.assert_called_once() + assert tel.camera_acq_started is False + + def test_terminate_does_not_disconnect_user_camera(self, telops_module): + cam = _make_fake_pytelops_camera() + tel = telops_module.TelopsCamera(camera=cam) + tel.terminate_data_source() + cam.acquisition_stop.assert_called_once() + cam.disconnect.assert_not_called() + + def test_terminate_idempotent(self, telops_module): + """Calling terminate_data_source twice must not double-call cleanup.""" + cam = _make_fake_pytelops_camera() + tel = telops_module.TelopsCamera(camera=cam) + tel.terminate_data_source() + n_stop_after_first = cam.acquisition_stop.call_count + tel.terminate_data_source() + # Second terminate must be a no-op (camera_acq_started is False) + assert cam.acquisition_stop.call_count == n_stop_after_first + + def test_context_manager_lifecycle(self, telops_module): + cam = _make_fake_pytelops_camera() + tel = telops_module.TelopsCamera(camera=cam) + # Reset call counts after construction + cam.acquisition_start.reset_mock() + cam.acquisition_stop.reset_mock() + + with tel: + # set_data_source already called in __enter__ (no-op since + # camera_acq_started is True from constructor) + pass + # __exit__ calls terminate_data_source + cam.acquisition_stop.assert_called_once() + + +class TestTelopsCameraImportError: + """If pyTelops is missing, the constructor must raise a clear ImportError.""" + + def test_missing_pytelops_raises(self, monkeypatch): + """When _PyTelopsCamera is None (the sentinel set by the + plugin's ``except ImportError`` block), constructing TelopsCamera + must raise ImportError with a helpful message.""" + import LDAQ.telops.acquisition as mod + monkeypatch.setattr(mod, "_PyTelopsCamera", None) + with pytest.raises(ImportError, match="pyTelops is not installed"): + mod.TelopsCamera()