pymagnetos 0.1.0__py3-none-any.whl

pymagnetos/pyuson/gui/widgets/__init__.py

@@ -0,0 +1,7 @@
+"""Custom widgets for pyuson, the GUI for ultra-sound experiments."""
+
+from ._buttons import ButtonsWidget
+from ._configuration import ConfigurationWidget, ParamContent
+from ._graphs import GraphsWidget
+
+__all__ = ["ButtonsWidget", "ConfigurationWidget", "GraphsWidget", "ParamContent"]

pymagnetos/pyuson/gui/widgets/_buttons.py

@@ -0,0 +1,95 @@
+"""The widget that hosts the grid with the main action buttons for pyuson."""
+
+from PyQt6 import QtWidgets
+from PyQt6.QtCore import Qt, pyqtSignal
+
+
+class ButtonsWidget(QtWidgets.QWidget):
+    """
+    The main action buttons.
+
+    pyqtSignals
+    -------
+    sig_load : emits when the "Load data" button is clicked.
+    sig_show : emits when the "Show frames" button is clicked.
+    sig_rolling : emits when the "Rolling average" button is clicked.
+    sig_refresh : emits when the "Refresh" button is clicked.
+    sig_save_csv : emits when the "Export as CSV" button is clicked.
+    sig_save_nexus : emits when the "Save as NeXus" button is clicked.
+    """
+
+    sig_load = pyqtSignal()
+    sig_show = pyqtSignal()
+    sig_rolling = pyqtSignal()
+    sig_refresh = pyqtSignal()
+    sig_save_csv = pyqtSignal()
+    sig_save_nexus = pyqtSignal()
+
+    def __init__(self) -> None:
+        super().__init__()
+        """Initialize buttons."""
+        # Create grid
+        grid = QtWidgets.QGridLayout()
+
+        # Create buttons
+        # Load data
+        self.button_load = QtWidgets.QPushButton("Load data", self)
+        # Show some frames
+        self.button_show = QtWidgets.QPushButton("Show frames", self)
+        # Apply moving mean filter
+        self.button_rolling = QtWidgets.QPushButton("Rolling average", self)
+        # Trigger computation of attenuation and phase shift
+        self.button_refresh = QtWidgets.QPushButton("Refresh", self)
+        # Export as CSV
+        self.button_save_csv = QtWidgets.QPushButton("Export as CSV", self)
+        # Checkbox to convert to dB/cm
+        self.checkbox_to_cm = QtWidgets.QCheckBox("Convert to dB/cm in CSV", self)
+        self.checkbox_to_cm.setChecked(True)
+
+        # Save as NeXus
+        self.button_save_nexus = QtWidgets.QPushButton("Save as NeXus", self)
+
+        # Disable all buttons
+        self.disable_buttons()
+
+        # Connect them
+        self.connect_buttons()
+
+        # Add buttons to layout
+        grid.addWidget(self.button_load, 0, 0)
+        grid.addWidget(self.button_show, 0, 1)
+        grid.addWidget(self.button_rolling, 1, 0)
+        grid.addWidget(self.button_refresh, 1, 1)
+        grid.addWidget(self.button_save_csv, 2, 0)
+        grid.addWidget(self.button_save_nexus, 2, 1)
+        grid.addWidget(self.checkbox_to_cm, 3, 0, Qt.AlignmentFlag.AlignHCenter)
+
+        # Set widget layout
+        self.setLayout(grid)
+
+    def connect_buttons(self) -> None:
+        """Connect the buttons to their signals."""
+        self.button_load.clicked.connect(self.sig_load.emit)
+        self.button_show.clicked.connect(self.sig_show.emit)
+        self.button_rolling.clicked.connect(self.sig_rolling.emit)
+        self.button_refresh.clicked.connect(self.sig_refresh.emit)
+        self.button_save_csv.clicked.connect(self.sig_save_csv.emit)
+        self.button_save_nexus.clicked.connect(self.sig_save_nexus.emit)
+
+    def disable_buttons(self) -> None:
+        """Disable all buttons."""
+        self.button_load.setEnabled(False)
+        self.button_rolling.setEnabled(False)
+        self.button_show.setEnabled(False)
+        self.button_refresh.setEnabled(False)
+        self.button_save_csv.setEnabled(False)
+        self.button_save_nexus.setEnabled(False)
+
+    def enable_buttons(self) -> None:
+        """Enable all buttons (except Load data)."""
+        self.button_load.setEnabled(False)
+        self.button_rolling.setEnabled(True)
+        self.button_show.setEnabled(True)
+        self.button_refresh.setEnabled(True)
+        self.button_save_csv.setEnabled(True)
+        self.button_save_nexus.setEnabled(True)

pymagnetos/pyuson/gui/widgets/_configuration.py

@@ -0,0 +1,85 @@
+"""The Configuration widget for pyuson."""
+
+from functools import partial
+
+from PyQt6.QtCore import pyqtSignal
+from pyqtgraph.parametertree import Parameter
+
+from pymagnetos.core.gui.widgets import BaseConfigurationWidget
+
+from ._param_content import ParamContent
+
+
+class ConfigurationWidget(BaseConfigurationWidget):
+    """
+    Initialize a PyQtGraph ParameterTree.
+
+    pyqtSignals
+    -------
+    sig_echo_index_changed : emits when the echo index (in the Settings section ) is
+        changed.
+    sig_find_f0 : emits when the "Find f0" button is clicked.
+    sig_demodulate : emits when the "Demodulate" button is clicked.
+    """
+
+    sig_echo_index_changed = pyqtSignal()
+    sig_find_f0 = pyqtSignal()
+    sig_demodulate = pyqtSignal()
+
+    def __init__(self, param_content: type[ParamContent]) -> None:
+        super().__init__(param_content)
+
+    def init_demodulation_tree(self) -> None:
+        """Create ParameterTree for demodulation parameters."""
+        if not hasattr(self._param_content, "children_demodulation"):
+            raise ValueError(
+                "Could not add the demodulation parameter tree, not in digital mode"
+            )
+        self.demodulation_parameters = Parameter.create(
+            name="Demodulation",
+            type="group",
+            children=self._param_content.children_demodulation,
+        )
+        self.host_parameters.addChild(self.demodulation_parameters)
+
+        # Store buttons as the others
+        self.button_findf0 = self.demodulation_parameters.child("find_f0")
+        self.button_findf0.setOpts(enabled=False)
+        self.button_demodulate = self.demodulation_parameters.child("demodulate")
+        self.button_demodulate.setOpts(enabled=False)
+
+        self.connect_to_signals_demodulation()
+
+    def connect_to_signals(self) -> None:
+        """Connect changes to signals."""
+        super().connect_to_signals()
+
+        # Special case for echo_index to sync it with another spinbox in the Batch
+        # processing tab
+        self.settings_parameters.child("echo_index").sigValueChanged.connect(
+            self.sig_echo_index_changed.emit
+        )
+
+    def connect_to_signals_demodulation(self) -> None:
+        """Additionnal connections for demodulation."""
+        self.button_findf0.sigActivated.connect(self.sig_find_f0.emit)
+        self.button_demodulate.sigActivated.connect(self.sig_demodulate.emit)
+
+        for p in self.demodulation_parameters:
+            self.demodulation_parameters.child(p.name()).sigValueChanged.connect(
+                partial(self.sig_parameter_changed.emit, p.name(), "demodulation")
+            )
+
+    def enable_buttons(self) -> None:
+        super().enable_buttons()
+        if hasattr(self, "button_findf0"):
+            self.button_findf0.setOpts(enabled=True)
+        if hasattr(self, "button_demodulate"):
+            self.button_demodulate.setOpts(enabled=True)
+
+    def disable_buttons(self) -> None:
+        super().disable_buttons()
+        if hasattr(self, "button_findf0"):
+            self.button_findf0.setOpts(enabled=False)
+        if hasattr(self, "button_demodulate"):
+            self.button_demodulate.setOpts(enabled=False)

pymagnetos/pyuson/gui/widgets/_graphs.py

@@ -0,0 +1,248 @@
+"""The graph area widget for pyuson."""
+
+import pyqtgraph as pg
+from PyQt6 import QtCore, QtWidgets
+from PyQt6.QtCore import pyqtSignal, pyqtSlot
+
+from pymagnetos.core.gui.widgets import BaseGraphsWidget
+
+
+class GraphsWidget(BaseGraphsWidget):
+    """
+    The graphs area with all the plots.
+
+    pyqtSignals
+    -------
+    sig_roi_changed : emits when the draggable time-window moved.
+    """
+
+    sig_roi_changed = pyqtSignal()
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        # Internal conversion factor from time to frames
+        self._time2frame_scale = 1.0
+
+        # Create empty canvases in tabs
+        field_tab = self.create_field_plot()
+        frame_tab = self.create_frame_plot()
+        amplitude_tab = self.create_amplitude_plot()
+        phase_tab = self.create_phase_plot()
+
+        self.init_coordinates_on_hover()
+
+        # Create a main splitter for rows (vertical)
+        main_splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Vertical)
+
+        # Create a top splitter for the first row (horizontal)
+        top_splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Horizontal)
+        top_splitter.addWidget(field_tab)
+        top_splitter.addWidget(frame_tab)
+        top_splitter.setStretchFactor(0, 1)  # field_tab stretch factor
+        # frame_tab spans 3 columns
+        top_splitter.setStretchFactor(1, 3)
+
+        # Create a bottom splitter for the second row (horizontal)
+        bottom_splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Horizontal)
+        bottom_splitter.addWidget(amplitude_tab)
+        bottom_splitter.addWidget(phase_tab)
+        # amplitude_tab spans 2 columns
+        bottom_splitter.setStretchFactor(0, 2)
+        # phase_tab spans 2 columns
+        bottom_splitter.setStretchFactor(1, 2)
+
+        # Add the top and bottom splitters to the main splitter
+        main_splitter.addWidget(top_splitter)
+        main_splitter.addWidget(bottom_splitter)
+        main_splitter.setStretchFactor(0, 1)  # top row stretch factor
+        main_splitter.setStretchFactor(1, 1)  # bottom row stretch factor
+
+        # Set the main splitter as the central widget
+        layout = QtWidgets.QVBoxLayout()
+        layout.addWidget(main_splitter)
+        self.setLayout(layout)
+
+    @property
+    def time2frame_scale(self) -> float:
+        return self._time2frame_scale
+
+    @time2frame_scale.setter
+    def time2frame_scale(self, value: float) -> None:
+        self._time2frame_scale = value
+        self.field.getAxis("top").setScale(self.time2frame_scale)
+        self.dfield.getAxis("top").setScale(self.time2frame_scale)
+
+    def create_field_plot(self) -> QtWidgets.QTabWidget:
+        tab = QtWidgets.QTabWidget(self)
+
+        # magnetic field (integrated)
+        self.field = pg.PlotWidget(title="Magnetic field")
+        self.field.setLabel("bottom", "time (s)")
+        self.field.setLabel("top", "frame (#) - field not aligned")
+        self.field.setLabel("left", "field (T)")
+        self.field.showGrid(y=True)
+        self._plots_list.add(self.field)
+
+        # pickup coil voltage (measured)
+        self.dfield = pg.PlotWidget(title="Pickup")
+        self.dfield.setLabel("bottom", "time (s)")
+        self.dfield.setLabel("top", "frame (#)")
+        self.dfield.setLabel("left", "pickup (V)")
+        self.dfield.showGrid(y=True)
+        self._plots_list.add(self.dfield)
+
+        tab.addTab(self.field, "B(t)")
+        tab.addTab(self.dfield, "Pickup")
+
+        return tab
+
+    def create_frame_plot(self) -> QtWidgets.QTabWidget:
+        tab = QtWidgets.QTabWidget(self)
+
+        # amplitude
+        self.amp_frame = pg.PlotWidget(title="Frames amplitude")
+        self.amp_frame.setLabel("bottom", "time (µs)")
+        self.amp_frame.setLabel("left", "signal (V)")
+        self.amp_frame.showGrid(y=True)
+        self.roi = pg.LinearRegionItem()  # time range selector
+        self.roi.sigRegionChangeFinished.connect(self.roi1_changed)
+        self.roi.sigRegionChangeFinished.connect(self.sig_roi_changed.emit)
+        self.amp_frame.addItem(self.roi, ignoreBounds=True)  # ty:ignore[unknown-argument]
+        self._plots_list.add(self.amp_frame)
+
+        # phases
+        self.phase_frame = pg.PlotWidget(title="Frames phase")
+        self.phase_frame.setLabel("bottom", "time (µs)")
+        self.phase_frame.setLabel("left", "signal (V)")
+        self.phase_frame.showGrid(y=True)
+        self.roi2 = pg.LinearRegionItem()  # twin in phase plot
+        self.phase_frame.addItem(self.roi2, ignoreBounds=True)  # ty:ignore[unknown-argument]
+        self.roi2.sigRegionChangeFinished.connect(self.roi2_changed)
+        self.phase_frame.getPlotItem().addLegend()
+        self._plots_list.add(self.phase_frame)
+
+        tab.addTab(self.amp_frame, "Frame amplitude")
+        tab.addTab(self.phase_frame, "Frame phase")
+
+        # Keep a reference to it to add more plots if needed
+        self.tab_frame_plot = tab
+
+        return tab
+
+    def add_reference_in_frame_tab(self) -> None:
+        """Add a plot for the reference signal for digital demodulation."""
+        if hasattr(self, "reference_frame") and isinstance(
+            self.reference_frame, pg.PlotWidget
+        ):
+            # Already has a reference frame plot
+            return
+        self.reference_frame = pg.PlotWidget(title="Frames reference")
+        self.reference_frame.setLabel("bottom", "time (µs)")
+        self.reference_frame.setLabel("left", "signal (V)")
+        self.reference_frame.showGrid(y=True)
+        self._plots_list.add(self.reference_frame)
+        self.coordinates_on_hover(self.reference_frame)
+
+        self.tab_frame_plot.addTab(self.reference_frame, "Frame reference")
+
+    def create_amplitude_plot(self) -> QtWidgets.QTabWidget:
+        tab = QtWidgets.QTabWidget(self)
+
+        # vs field
+        self.amp_field = pg.PlotWidget(title="Amplitude (B)")
+        self.amp_field.setLabel("bottom", "field (T)")
+        self.amp_field.setLabel("left", "attenuation (dB/cm)")
+        self.amp_field.showGrid(y=True)
+        self.amp_field.getPlotItem().addLegend()
+        self._plots_list.add(self.amp_field)
+
+        # vs amplitude
+        self.amp_time = pg.PlotWidget(title="Amplitude (t)")
+        self.amp_time.setLabel("bottom", "time (s)")
+        self.amp_time.setLabel("left", "attenuation (dB/cm)")
+        self.amp_time.showGrid(y=True)
+        self._plots_list.add(self.amp_time)
+
+        tab.addTab(self.amp_field, "Amplitude (B)")
+        tab.addTab(self.amp_time, "Amplitude (t)")
+
+        return tab
+
+    def create_phase_plot(self) -> QtWidgets.QTabWidget:
+        tab = QtWidgets.QTabWidget(self)
+
+        # vs field
+        self.phase_field = pg.PlotWidget(title="Phase (B)")
+        self.phase_field.setLabel("bottom", "field (T)")
+        self.phase_field.setLabel("left", "dphi/phi")
+        self.phase_field.showGrid(y=True)
+        self.phase_field.getPlotItem().addLegend()
+        self._plots_list.add(self.phase_field)
+
+        # vs plot
+        self.phase_time = pg.PlotWidget(title="Phase (t)")
+        self.phase_time.setLabel("bottom", "time (s)")
+        self.phase_time.setLabel("left", "dphi/phi")
+        self.phase_time.showGrid(y=True)
+        self._plots_list.add(self.phase_time)
+
+        tab.addTab(self.phase_field, "Phase (B)")
+        tab.addTab(self.phase_time, "Phase (t)")
+
+        return tab
+
+    def init_plot_style(self) -> None:
+        """Set up PyQtGraph line styles."""
+        w0 = 1
+        w1 = 1
+        self.pen_field = pg.mkPen("#c7c7c7", width=w0)
+        self.pen_amp = pg.mkPen("#1f77b480", width=w0)
+        self.pen_amp_demod = pg.mkPen("#d6272880", width=w0)
+        self.pen_in_phase = pg.mkPen("#ff7f0e80", width=w1)
+        self.pen_out_phase = pg.mkPen("#17becf80", width=w1)
+        self.pen_phase_demod = pg.mkPen("#9467bd80", width=w0)
+        self.pen_bup = pg.mkPen("#2ca02cbf", width=w0)
+        self.pen_bdown = pg.mkPen("#d62728bf", width=w0)
+
+    def init_field_crosshair(self) -> None:
+        """Create line cursor on field plot that tracks frame number."""
+        self.field_vline = pg.InfiniteLine(angle=90, movable=False)
+        self.field.addItem(self.field_vline, ignoreBounds=True)  # ty:ignore[unknown-argument]
+        self.field.scene().sigMouseMoved.connect(self.field_crosshair_moved)  # ty:ignore[possibly-missing-attribute]
+
+    def field_crosshair_moved(self, evt) -> None:
+        """Define the callback function when the cursor is moved."""
+        pos = evt
+        vb = self.field.getViewBox()
+        if self.field.sceneBoundingRect().contains(pos):
+            mouse_point = vb.mapSceneToView(pos)
+            index = int(mouse_point.x() * self.time2frame_scale)
+            self.field.setLabel("top", f"frame (#), current : {index}")
+            self.field_vline.setPos(mouse_point.x())
+
+    @pyqtSlot()
+    def roi1_changed(self) -> None:
+        """Update ROI in the phase panel when the ROI in the amplitude panel moved."""
+        roi1 = self.roi.getRegion()  # amplitude panel
+        roi2 = self.roi2.getRegion()  # phase panel
+        if roi1 != roi2:
+            self.roi2.setRegion(self.roi.getRegion())
+
+    @pyqtSlot()
+    def roi2_changed(self) -> None:
+        """Update ROI in the amplitude panel when the ROI in the phase panel moved."""
+        roi1 = self.roi.getRegion()  # amplitude panel
+        roi2 = self.roi2.getRegion()  # phase panel
+        if roi1 != roi2:
+            self.roi.setRegion(self.roi2.getRegion())
+
+    def enable_rois(self) -> None:
+        """Enable moving ROIs."""
+        self.roi.setMovable(True)
+        self.roi2.setMovable(True)
+
+    def disable_rois(self) -> None:
+        """Disable moving ROIs."""
+        self.roi.setMovable(False)
+        self.roi2.setMovable(False)

pymagnetos/pyuson/gui/widgets/_param_content.py

@@ -0,0 +1,193 @@
+"""ParameterTree content for pyuson."""
+
+import numpy as np
+
+from pymagnetos.core.gui.widgets import BaseParamContent
+
+
+class ParamContent(BaseParamContent):
+    # List of parameters that will need to be parsed from string to list
+    PARAMS_TO_PARSE = ["frame_indices", "range_baseline", "analysis_window"]
+
+    # Define parameters in the "Parameters" section
+    children_parameters = [
+        dict(
+            name="pickup_surface",
+            type="float",
+            limits=[0, np.inf],
+            value=None,
+            suffix="m²",
+            siPrefix=False,
+            readonly=True,
+            title="Pickup surface",
+        ),
+        dict(
+            name="pickup_samplerate",
+            type="float",
+            limits=[0, np.inf],
+            value=250e3,
+            step=1e3,
+            suffix="Hz",
+            siPrefix=True,
+            readonly=True,
+            title="Pickup sample rate",
+        ),
+        dict(
+            name="sample_length",
+            type="float",
+            limits=[0, np.inf],
+            value=None,
+            step=0.5e-3,
+            suffix="m",
+            siPrefix=True,
+            readonly=True,
+            title="Sample length",
+        ),
+        dict(
+            name="sample_speed",
+            type="float",
+            limits=[0, np.inf],
+            value=None,
+            step=0.5e3,
+            suffix="m/s",
+            siPrefix=True,
+            readonly=True,
+            title="Sample speed",
+        ),
+        dict(
+            name="detection_mode",
+            type="list",
+            limits=["reflection", "transmission"],
+            value="reflection",
+            readonly=True,
+            title="Detection mode",
+        ),
+    ]
+
+    # Define parameters in the "Settings" section (editable)
+    children_settings = [
+        dict(
+            name="echo_index",
+            type="int",
+            limits=[1, np.inf],
+            step=1,
+            value=1,
+            title="Echo index",
+        ),
+        dict(name="frame_indices", type="str", title="Displayed frames"),
+        dict(
+            name="rolling_mean_wlen",
+            type="int",
+            limits=[0, np.inf],
+            step=1,
+            value=0,
+            title="Rolling mean window length",
+        ),
+        dict(
+            name="rolling_mean_subsample",
+            type="bool",
+            limits=[True, False],
+            value=False,
+            title="Rolling mean subsampling",
+        ),
+        dict(name="range_baseline", type="str", value="", title="Range baseline"),
+        dict(
+            name="analysis_window", type="str", value="", title="Analysis time window"
+        ),
+        dict(
+            name="max_phase_jump",
+            type="float",
+            value=0.5,
+            step=0.1,
+            limits=[0, np.inf],
+            title="Max. phase jump (* π)",
+        ),
+    ]
+
+    children_demodulation = [
+        dict(
+            name="f0",
+            type="float",
+            limits=[0, np.inf],
+            step=10e6,
+            value=0,
+            suffix="Hz",
+            siPrefix=True,
+            title="f0",
+        ),
+        dict(
+            name="fft_nframes",
+            type="int",
+            limits=[0, np.inf],
+            step=10,
+            value=0,
+            title="FFT : nframes",
+        ),
+        dict(
+            name="detrend",
+            type="bool",
+            limits=[False, True],
+            value=False,
+            title="FFT : detrend",
+        ),
+        dict(
+            name="findsig_nframes",
+            type="int",
+            limit=[0, np.inf],
+            step=10,
+            value=0,
+            title="Ref. finder : nframes",
+        ),
+        dict(
+            name="findsig_nstd",
+            type="float",
+            limit=[0, np.inf],
+            step=0.1,
+            value=1.5,
+            title="Ref. finder : nstd",
+        ),
+        dict(
+            name="findsig_extend",
+            type="float",
+            limit=[-np.inf, np.inf],
+            step=0.01,
+            value=-0.10,
+            title="Ref. finder : ext. frac.",
+        ),
+        dict(
+            name="chunksize",
+            type="int",
+            limits=[-1, np.inf],
+            step=100,
+            value=0,
+            title="Chunk size",
+        ),
+        dict(
+            name="decimate_factor",
+            type="int",
+            limits=[0, np.inf],
+            step=1,
+            value=0,
+            title="Decimation factor",
+        ),
+        dict(
+            name="filter_order",
+            type="int",
+            limits=[1, np.inf],
+            step=1,
+            value=10,
+            title="Filter order",
+        ),
+        dict(
+            name="filter_fc",
+            type="float",
+            limits=[0, np.inf],
+            step=10e6,
+            value=300e6,
+            suffix="Hz",
+            siPrefix=True,
+            title="Filter cut-off frequency",
+        ),
+        dict(name="find_f0", type="action", title="Find f0"),
+        dict(name="demodulate", type="action", title="Demodulate"),
+    ]

pymagnetos-0.1.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.3
+Name: pymagnetos
+Version: 0.1.0
+Summary: Applications for high magnetic field analysis
+Author: Guillaume Le Goc
+Author-email: Guillaume Le Goc <guillaume.le-goc@lncmi.cnrs.fr>
+License: MIT
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: fftekwfm>=0.3.0.1
+Requires-Dist: matplotlib>=3.10.8
+Requires-Dist: nexusformat>=2.0.0
+Requires-Dist: numpy>=2.4.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyqt6>=6.10.2
+Requires-Dist: pyqtgraph>=0.14.0
+Requires-Dist: rich>=14.3.1
+Requires-Dist: scipy>=1.17.0
+Requires-Dist: tomlkit>=0.14.0
+Requires-Python: >=3.13
+Project-URL: Source Code, https://gitlab.in2p3.fr/himagnetos/pymagnetos
+Description-Content-Type: text/markdown
+