qplotter 1.6.0__py3-none-any.whl

qplot/windows/plot1d.py

@@ -0,0 +1,313 @@
+from typing import Any, Literal
+
+import numpy as np
+import numpy.typing as npt
+from PyQt6 import (
+    QtCore,
+)
+
+from qplot.datahandling.parameter_data import numeric_isfinite
+
+from ._mixed_plots import MixedPlotMixin
+from ._native_transforms import NativePlotDataItem
+from ._plot1d_snap import Plot1DSnapMixin, _line_snap_data
+from ._plot_data_viewbox import coordinate_viewbox
+from ._plotWin import plotWidget
+
+
+class plot1d(Plot1DSnapMixin, MixedPlotMixin, plotWidget):
+    """
+    Plot window for 1d Line plots.
+    Inherits and wraps several functions from qplot.windows._plotWin.plotWidget.
+    PlotWidget handles majority of set up, recommend to view first.
+    
+    Key functions to see in plot1d:
+        initFrame
+        refreshPlot
+        
+    Snap-to-trace behavior lives in qplot.windows._plot1d_snap.
+    Trace-control and secondary-axis behavior lives in
+    qplot.windows._plot1d_traces.
+    
+    """
+    operation_kind = "plot1d"
+    get_mergables = QtCore.pyqtSignal()
+    remove_dataset = QtCore.pyqtSignal([object])
+    
+    def __init__(
+            self,
+            *args: Any,
+            **kargs: Any,
+            ) -> None:
+        self.mergable = None
+        self.line = None
+        self.right_vb = None
+        self.top_vb = None
+        self.top_right_vb = None
+        self.snap_to_trace_action = None
+        self.trace_label = None
+        self.snap_marker = None
+        self._snap_marker_view = None
+        super().__init__(*args, **kargs)
+        
+        
+    def initFrame(self) -> None:
+        """
+        Sets up the initial plot and starting data.
+
+        """
+        
+        self.line = NativePlotDataItem(connect="all")
+        self.plot.addItem(self.line)
+        self._register_main_line()
+        
+        # Wait for loader to finish to enure needed data is collected.
+        self.load_data()
+        self.show_status("Line plot ready; loading data...", 5000)
+
+
+    def _marquee_viewbox(self) -> Any:
+        """Use the main trace's coordinate system for selection and hit tests."""
+
+        line = self.__dict__.get("line")
+        get_viewbox = getattr(line, "getViewBox", None)
+        viewbox = get_viewbox() if callable(get_viewbox) else None
+        return coordinate_viewbox(viewbox) if viewbox is not None else super()._marquee_viewbox()
+
+
+    def _marquee_zoom_viewbox(self, axis: Literal["x", "y"]) -> Any:
+        # Axis-pair ViewBoxes contain linked dimensions. Change the actual
+        # range owner so a later link update cannot undo the selection zoom.
+        line = self.__dict__.get("line")
+        return self._axis_scale_viewbox(self._axis_scale_axis_for_line(line, axis))
+
+
+    def _snap_marquee_rect(self, rect: QtCore.QRectF) -> QtCore.QRectF:
+        """
+        Snap marquee X edges to the spaces between plotted data points.
+
+        """
+        boundaries = self._marquee_x_boundaries()
+        if boundaries is None:
+            return rect
+
+        left_index = int(np.searchsorted(boundaries, rect.left(), side="right")) - 1
+        right_index = int(np.searchsorted(boundaries, rect.right(), side="left"))
+        left_index = min(max(left_index, 0), len(boundaries) - 2)
+        right_index = min(max(right_index, left_index + 1), len(boundaries) - 1)
+
+        return QtCore.QRectF(
+            boundaries[left_index],
+            rect.top(),
+            boundaries[right_index] - boundaries[left_index],
+            rect.height(),
+            )
+
+
+    def _marquee_x_boundaries(self) -> npt.NDArray[np.float64] | None:
+        """
+        Return X coordinates halfway between full trace sample points.
+
+        """
+        x_data = None
+        line = self.__dict__.get("line")
+        if line is not None:
+            data = _line_snap_data(line)
+            if data is not None:
+                x_data = data.x_view
+
+        if x_data is None:
+            x_data = self.__dict__.get("axis_data", {}).get("x")
+
+        if x_data is None:
+            return None
+
+        values = np.asarray(x_data, dtype=float)
+        values = np.unique(values[np.isfinite(values)])
+        if values.size == 0:
+            return None
+        if values.size == 1:
+            point = float(values[0])
+            return np.array([point - 0.5, point + 0.5])
+
+        gaps = np.diff(values)
+        mids = values[:-1] + gaps / 2
+        first = values[0] - gaps[0] / 2
+        last = values[-1] + gaps[-1] / 2
+        return np.concatenate(([first], mids, [last]))
+
+
+    def _marquee_stats_text(self) -> str | None:
+        values = self._marquee_line_values()
+        if values is None:
+            return None
+
+        line = self.__dict__.get("line")
+        return self._format_marquee_stats_text(
+            f"{values.size} points",
+            values,
+            x_axis=self._axis_scale_axis_for_line(line, "x"),
+            y_axis=self._axis_scale_axis_for_line(line, "y"),
+        )
+
+
+    def _marquee_line_values(self) -> npt.NDArray[np.float64] | None:
+        if self.marquee is None:
+            return None
+
+        line = self.__dict__.get("line")
+        if line is not None:
+            data = _line_snap_data(line)
+            if data is None:
+                return None
+            x_data, y_data, raw_y_data = data.x_view, data.y_view, data.y_raw
+        else:
+            axis_data = self.__dict__.get("axis_data", {})
+            x_data = axis_data.get("x")
+            y_data = axis_data.get("y")
+            raw_y_data = y_data
+
+        if x_data is None or y_data is None or raw_y_data is None:
+            return None
+
+        x_data = np.asarray(x_data, dtype=float)
+        y_data = np.asarray(y_data, dtype=float)
+        raw_y_data = np.asarray(raw_y_data)
+        count = min(x_data.size, y_data.size, raw_y_data.size)
+        if count == 0:
+            return None
+
+        rect = self.marquee.normalized()
+        x_data = x_data[:count]
+        y_data = y_data[:count]
+        raw_y_data = raw_y_data[:count]
+        mask = (
+            np.isfinite(x_data)
+            & np.isfinite(y_data)
+            & numeric_isfinite(raw_y_data)
+            & (x_data >= rect.left())
+            & (x_data <= rect.right())
+            & (y_data >= rect.top())
+            & (y_data <= rect.bottom())
+            )
+        if not np.any(mask):
+            return None
+
+        return raw_y_data[mask]
+
+
+    def refreshPlot(self, finished: bool = True, worker: Any | None = None) -> None:
+        """
+        Updates plot based on data produced by the thread worker. Data is 
+        assigned in plotWidget.refreshPlot, then all plot items are produced
+        here.
+
+        Parameters
+        ----------
+        finished : bool
+            In the event the worker had to abort, finished is False and refresh
+            is not ran.
+        """
+        plot_worker = worker if worker is not None else self.worker
+        if not super().refreshPlot(finished, worker=worker):
+            return
+
+        try:
+            clear_display = lambda: self.line.setData([], [])
+            if not self._refresh_publication_source_is_current(
+                    plot_worker,
+                    clear_display=clear_display,
+                    ):
+                return
+            if not self._has_plottable_line_data():
+                self.line.setData([], [])
+                if not self._refresh_publication_source_is_current(
+                        plot_worker,
+                        clear_display=clear_display,
+                        ):
+                    return
+                self.show_status(
+                    f"Waiting for plottable data for {self.param.name}...",
+                    5000,
+                    )
+                self.show_plot_state(
+                    "Waiting for plottable data",
+                    f"{self.param.name} has no finite line data yet.",
+                    kind="empty",
+                )
+                self.trace_updated.emit()
+                if not self._refresh_publication_source_is_current(
+                        plot_worker,
+                        clear_display=clear_display,
+                        ):
+                    return
+                display_synchronized = self._mark_display_synchronized(
+                    plot_worker,
+                )
+                if (
+                    getattr(plot_worker, "dataset_completed", None) is True
+                    and not display_synchronized
+                ):
+                    return
+                if getattr(plot_worker, "_qplot_source_rejected", False):
+                    clear_display()
+                    return
+                self._commit_refresh_publication(plot_worker)
+                return
+
+            # Main line
+            self.line.setData(
+                x=self.axis_data["x"],
+                y=self.axis_data["y"],
+                )
+            if not self._refresh_publication_source_is_current(
+                    plot_worker,
+                    clear_display=clear_display,
+                    ):
+                return
+            if self.marquee is not None:
+                self.set_marquee_rect(self.marquee)
+
+            self.trace_updated.emit()
+            if not self._refresh_publication_source_is_current(
+                    plot_worker,
+                    clear_display=clear_display,
+                    ):
+                return
+            self.refresh_secondary_lines()
+            self.refresh_secondary_heatmaps()
+            if not self._refresh_publication_source_is_current(
+                    plot_worker,
+                    clear_display=clear_display,
+                    ):
+                return
+            self._mark_display_synchronized(plot_worker)
+            if getattr(plot_worker, "_qplot_source_rejected", False):
+                clear_display()
+                return
+            self._commit_refresh_publication(plot_worker, preview_ready=True)
+        finally:
+            overlay = self.__dict__.get("plot_state_overlay")
+            if overlay is not None:
+                overlay.finish(plot_worker)
+            if isinstance(
+                    getattr(plot_worker, "_qplot_publication_snapshot", None),
+                    dict,
+                    ):
+                if self._refresh_publication_source_is_current(
+                        plot_worker,
+                        clear_display=clear_display,
+                        ):
+                    self._commit_refresh_publication(plot_worker)
+            plot_worker.running = False
+            self._ensure_refresh_monitor()
+
+
+    def _has_plottable_line_data(self) -> bool:
+        x_data = np.asarray(self.axis_data.get("x", []), dtype=float)
+        y_data = np.asarray(self.axis_data.get("y", []), dtype=float)
+        count = min(x_data.size, y_data.size)
+        if count == 0:
+            return False
+
+        return bool(np.any(np.isfinite(x_data[:count]) & np.isfinite(y_data[:count])))