qplotter 1.6.0__py3-none-any.whl

qplot/windows/_plot_source_promotion.py

@@ -0,0 +1,178 @@
+"""Promote the bottom eligible dataset when a plot's source is removed."""
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any
+
+from PyQt6 import QtWidgets as qtw
+
+from ._plot_drop_axes import DropAxisPlan
+from ._refresh_interval import refresh_interval_value
+
+
+@dataclass
+class _DatasetAppearance:
+    kind: str
+    key: Any
+    source: Any
+    plan: DropAxisPlan
+    style: Any = None
+    opacity: float = 1.0
+    visible: bool = True
+
+
+def _remaining_datasets(owner, selected):
+    datasets = []
+    for kind, key in owner._plot_item_order:
+        if (kind, key) in selected:
+            continue
+        if kind == "trace":
+            item = owner.lines[key]
+            style = deepcopy(owner._ensure_trace_styles()[key])
+            order = item.source_axis_order() or ("x", "y")
+            plan = DropAxisPlan(order, style.x_axis, style.y_axis, ())
+            datasets.append(_DatasetAppearance(kind, key, item.from_win, plan, style))
+        else:
+            item = owner.heatmaps[key]
+            sides = owner._heatmap_axis_sides(item)
+            plan = DropAxisPlan(item.source_axis_order() or ("x", "y"), sides[0], sides[1], ())
+            datasets.append(_DatasetAppearance(
+                kind, key, item.from_win, plan,
+                opacity=owner._heatmap_opacity(item), visible=owner._heatmap_is_visible(item),
+            ))
+    return datasets
+
+
+def _copy_operations(source, target):
+    options = {target.list_options.item(index).operation_row.label: target.list_options.item(index)
+               for index in range(target.list_options.count())}
+    for index in range(source.list_order.count()):
+        row = source.list_order.item(index)
+        if row.isHidden():
+            continue
+        option = options[row.label]
+        option.input.setChecked(True)
+        old_input, new_input = row.input, option.operation_row.input
+        if isinstance(old_input, qtw.QLineEdit):
+            new_input.setText(old_input.text())
+        elif isinstance(old_input, qtw.QComboBox):
+            new_input.setCurrentText(old_input.currentText())
+        elif isinstance(old_input, qtw.QCheckBox):
+            new_input.setChecked(old_input.isChecked())
+    target._apply_generation = source._apply_generation
+
+
+def _copy_view(owner, replacement):
+    for axis in ("x", "y", "x2", "y2"):
+        if not replacement._axis_scale_axis_is_used(axis):
+            continue
+        old = owner._axis_scale_viewbox(axis)
+        new = replacement._axis_scale_viewbox(axis)
+        dimension = 0 if axis in ("x", "x2") else 1
+        replacement._axis_scale_log_toggled(axis, owner._axis_scale_log_mode(axis))
+        new.setRange(**{"xRange" if dimension == 0 else "yRange": old.viewRange()[dimension]}, padding=0)
+        new.enableAutoRange(dimension, old.state["autoRange"][dimension])
+        dimension_name = "x" if dimension == 0 else "y"
+        new.setAutoVisible(**{dimension_name: old.state["autoVisibleOnly"][dimension]})
+        new.setAutoPan(**{dimension_name: old.state["autoPan"][dimension]})
+        new.setMouseEnabled(**{"x" if dimension == 0 else "y": old.state["mouseEnabled"][dimension]})
+        if dimension == 0:
+            new.invertX(old.state["xInverted"])
+        else:
+            new.invertY(old.state["yInverted"])
+    replacement._axis_scale_custom_auto_axes = set(owner._axis_scale_custom_auto_axes)
+
+
+def _copy_window_layout(owner, replacement):
+    for window in (owner, replacement):
+        for widget_type in (qtw.QDockWidget, qtw.QToolBar):
+            for widget in window.findChildren(widget_type):
+                widget.setObjectName(f"{widget_type.__name__}:{widget.windowTitle()}")
+    replacement.restoreState(owner.saveState())
+    replacement.setGeometry(owner.geometry())
+
+
+def promote_plot_source(main: Any, owner: Any, selected: list[tuple[str, Any]]) -> Any:
+    """Rebuild the source-specific controls and release the old plot owner.
+
+    Construct the replacement before closing the old owner, so every surviving
+    dataset stays retained and a construction failure leaves the plot intact.
+    Rebuilding also supports a change between trace and heatmap source types.
+    """
+    datasets = _remaining_datasets(owner, selected)
+    # Cuts have their own linked controls and cannot host a mixed plot. Keep
+    # their overlays in place while choosing the bottom eligible full source.
+    primary = next((dataset for dataset in reversed(datasets)
+                    if dataset.source.operation_kind in {"plot1d", "plot2d"}), None)
+    if primary is None:
+        raise ValueError("Keep a full line or heatmap dataset in this plot; cuts cannot be its primary source.")
+    source = primary.source
+    dialog = owner.__dict__.get("_plot_appearance_dialog")
+    show_dialog = dialog is not None and dialog.isVisible()
+    dialog_geometry = dialog.saveGeometry() if show_dialog else None
+    previous_windows = set(main.windows)
+    next_position = main._plot_tile_grid, main._next_plot_tile
+    replacement = None
+    try:
+        main.openWin(type(source), source._dataset_key, source.param,
+                     refrate=refresh_interval_value(owner.spinBox), show=True)
+        replacement = next(win for win in main.windows if win not in previous_windows)
+        _copy_window_layout(owner, replacement)
+        _copy_operations(source.oper_widget, replacement.oper_widget)
+        order = primary.plan.axis_order
+        for dimension, source_axis in zip(("x", "y"), order, strict=True):
+            combo = replacement.axis_dropdown[dimension]
+            blocked = combo.blockSignals(True)
+            combo.setCurrentText(source.axis_options[source_axis])
+            combo.blockSignals(blocked)
+        replacement._axis_selection = replacement.axis_options
+        remapped_order: list[tuple[str, Any]] = []
+        for dataset in reversed(datasets):
+            if dataset is primary:
+                key = replacement.label if dataset.kind == "trace" else replacement._primary_heatmap_key
+                item = replacement.line if dataset.kind == "trace" else replacement
+            else:
+                key = dataset.key
+                if dataset.kind == "trace":
+                    replacement.add_preview_trace(dataset.source, dataset.plan)
+                    item = replacement.lines[key]
+                else:
+                    replacement.add_heatmap(dataset.source, axis_plan=dataset.plan)
+                    item = replacement.heatmaps[key]
+            if dataset.kind == "trace":
+                replacement._ensure_trace_styles()[key] = dataset.style
+                replacement._apply_trace_style(key, item)
+            else:
+                replacement._set_layer_axes(item, dataset.plan.x_side, dataset.plan.y_side)
+                replacement._set_layer_opacity(item, dataset.opacity)
+                replacement._set_layer_visibility(item, dataset.visible)
+            remapped_order.insert(0, (dataset.kind, key))
+        replacement._plot_item_order = remapped_order
+        replacement._sync_plot_item_order()
+        for name in ("subtractMeanCheck", "phasemapCheck", "fftCheck", "derivativeCheck"):
+            getattr(replacement.plot.ctrl, name).setChecked(getattr(owner.plot.ctrl, name).isChecked())
+        if "_colorbar_colormap_name" in owner.__dict__:
+            replacement._colorbar_colormap_name = owner._colorbar_colormap_name
+            bar = replacement.__dict__.get("bar")
+            if bar is not None:
+                bar.setColorMap(replacement._colorbar_colormap())
+        replacement._colorbar_manual_levels = owner.__dict__.get("_colorbar_manual_levels")
+        replacement._sync_heatmap_colorbar_items(rescale=True)
+        _copy_view(owner, replacement)
+        replacement.refreshWindow(force=True)
+    except Exception:
+        for win in list(main.windows):
+            if win not in previous_windows:
+                win.close()
+                win.deleteLater()
+        raise
+    finally:
+        main._plot_tile_grid, main._next_plot_tile = next_position
+    owner.close()
+    if owner._merged_trace_users <= 0:
+        owner.deleteLater()
+    replacement.show()
+    if show_dialog:
+        replacement.open_plot_appearance_dialog()
+        replacement._plot_appearance_dialog.restoreGeometry(dialog_geometry)
+    return replacement

qplot/windows/_plot_state.py

@@ -0,0 +1,237 @@
+from time import perf_counter
+from typing import Any
+
+from PyQt6 import QtCore
+from PyQt6 import QtWidgets as qtw
+
+from qplot.datahandling.plot_progress import PlotProgress
+
+from ._plot_status import PlotStatusWidget
+
+
+class PlotStateOverlay(QtCore.QObject):
+    """
+    Keep empty/error explanations in the plot and loading progress in its toolbar.
+    """
+
+    _styles: dict[str, str] = {
+        "info": (
+            "background-color: rgba(250, 252, 255, 235);"
+            "border: 1px solid rgba(119, 135, 153, 190);"
+            "color: #1f2933;"
+            ),
+        "loading": (
+            "background-color: rgba(246, 251, 255, 238);"
+            "border: 1px solid rgba(70, 130, 180, 190);"
+            "color: #102a43;"
+            ),
+        "empty": (
+            "background-color: rgba(255, 251, 235, 238);"
+            "border: 1px solid rgba(180, 132, 35, 190);"
+            "color: #3b2f12;"
+            ),
+        "error": (
+            "background-color: rgba(255, 245, 245, 240);"
+            "border: 1px solid rgba(190, 72, 72, 200);"
+            "color: #3b0d0c;"
+            ),
+    }
+
+    def __init__(self, target: qtw.QWidget, feedback: PlotStatusWidget) -> None:
+        super().__init__(target)
+        self.feedback = feedback
+        self.owner: qtw.QWidget = target
+        target_obj: Any = target
+        viewport = target_obj.viewport() if hasattr(target_obj, "viewport") else None
+        self.target: qtw.QWidget = viewport or target
+
+        self.frame = qtw.QFrame(self.target)
+        self.frame.setObjectName("plotStateOverlay")
+        self.frame.setAttribute(QtCore.Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
+        self.frame.setAutoFillBackground(False)
+
+        layout = qtw.QVBoxLayout(self.frame)
+        layout.setContentsMargins(14, 10, 14, 10)
+        layout.setSpacing(4)
+
+        self.title_label = qtw.QLabel(self.frame)
+        self.title_label.setObjectName("plotStateOverlayTitle")
+        title_font = self.title_label.font()
+        title_font.setBold(True)
+        self.title_label.setFont(title_font)
+        self.title_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.title_label)
+
+        self.detail_label = qtw.QLabel(self.frame)
+        self.detail_label.setObjectName("plotStateOverlayDetail")
+        self.detail_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self.detail_label.setWordWrap(True)
+        layout.addWidget(self.detail_label)
+
+        self.progress_bar = feedback.progress_bar
+        self.elapsed_label = feedback.elapsed_label
+        self._worker: Any = None
+        self._last_progress: PlotProgress | None = None
+        self._started_at: float | None = None
+        self._rendering = False
+        self.progress_timer = QtCore.QTimer(self)
+        self.progress_timer.setInterval(100)
+        self.progress_timer.timeout.connect(self._poll_progress)
+
+        self.target.installEventFilter(self)
+        if self.owner is not self.target:
+            self.owner.installEventFilter(self)
+        self.hide()
+
+    def show(
+            self,
+            title: object,
+            detail: object | None = None,
+            kind: str = "info",
+            ) -> None:
+        if kind != "loading":
+            self._stop_progress()
+        self.title_label.setText(str(title or ""))
+        self.detail_label.setText(str(detail or ""))
+        self.detail_label.setVisible(bool(detail))
+        if kind == "loading":
+            self.frame.hide()
+            return
+        self.feedback.show_message(" — ".join(str(value) for value in (title, detail) if value))
+        self.frame.setStyleSheet(self._stylesheet(kind))
+        self._sync_geometry()
+        self.frame.show()
+        self.frame.raise_()
+
+    def hide(self) -> None:
+        self._stop_progress()
+        self.frame.hide()
+
+    def track(self, worker: Any) -> None:
+        """Poll one latest value, never queue an event per reader chunk."""
+        self._worker = worker
+        self._last_progress = None
+        self._started_at = getattr(worker, "started_at", perf_counter())
+        self._rendering = False
+        self.feedback.start_progress()
+        self._poll_progress()
+        if self._worker is worker:
+            self.progress_timer.start()
+
+    def _stop_progress(self) -> None:
+        self.progress_timer.stop()
+        self._worker = None
+        self._last_progress = None
+        self._started_at = None
+        self._rendering = False
+        self.progress_bar.hide()
+        self.elapsed_label.hide()
+        self.feedback.finish_progress()
+
+    def _update_elapsed(self) -> None:
+        if self._started_at is None:
+            return
+        seconds = max(0, int(perf_counter() - self._started_at))
+        minutes, seconds = divmod(seconds, 60)
+        hours, minutes = divmod(minutes, 60)
+        duration = (f"{hours}h {minutes:02d}m {seconds:02d}s" if hours else
+                    f"{minutes}m {seconds:02d}s" if minutes else f"{seconds}s")
+        text = duration
+        if self.elapsed_label.text() != text:
+            self.elapsed_label.setText(text)
+        self.elapsed_label.show()
+
+    def _poll_progress(self) -> None:
+        worker = self._worker
+        if worker is None:
+            return
+        if worker.is_cancelled():
+            self.show("Plot load cancelled")
+            return
+        self._update_elapsed()
+        self.feedback.show_progress()
+        if self._rendering:
+            return
+        progress = worker.progress
+        if progress == self._last_progress:
+            return
+        self._last_progress = progress
+        self.feedback.set_progress_details(progress, self.title_label.text())
+        self.detail_label.setText(progress.title)
+        self.detail_label.show()
+        if progress.total is None or progress.total <= 0:
+            self.progress_bar.setRange(0, 0)
+            self.progress_bar.setFormat("")
+        else:
+            self.progress_bar.setRange(0, 1000)
+            self.progress_bar.setValue(min(1000, max(0, progress.completed * 1000 // progress.total)))
+            self.progress_bar.setFormat("%p%")
+        self.progress_bar.show()
+
+    def rendering(self, worker: Any) -> None:
+        if worker is not self._worker:
+            return
+        self._rendering = True
+        self._update_elapsed()
+        progress = PlotProgress("Rendering plot", stage=2)
+        self.detail_label.setText(progress.title)
+        self.feedback.set_progress_details(progress, self.title_label.text())
+        self.feedback.show_progress()
+        self.progress_bar.setRange(0, 0)
+        self.progress_bar.setFormat("")
+
+    def finish(self, worker: Any) -> None:
+        if worker is self._worker:
+            # Only a loading state is removed. Empty/error explanations stay.
+            self.hide()
+
+    def eventFilter(
+            self,
+            source: QtCore.QObject | None,
+            event: QtCore.QEvent | None,
+            ) -> bool:
+        if (
+                event is not None
+                and (source is self.owner or source is self.target)
+                and event.type() in (QtCore.QEvent.Type.Resize, QtCore.QEvent.Type.Show)
+                ):
+            self._sync_geometry()
+        return super().eventFilter(source, event)
+
+    def _stylesheet(self, kind: str) -> str:
+        panel_style = self._styles.get(kind, self._styles["info"])
+        return (
+            "QFrame#plotStateOverlay {"
+            f"{panel_style}"
+            "border-radius: 6px;"
+            "}"
+            "QLabel#plotStateOverlayTitle {"
+            "background: transparent;"
+            "font-size: 10pt;"
+            "}"
+            "QLabel#plotStateOverlayDetail {"
+            "background: transparent;"
+            "font-size: 8pt;"
+            "}"
+            "QLabel#plotStateOverlayElapsed {"
+            "background: transparent;"
+            "font-size: 8pt;"
+            "}"
+            )
+
+    def _sync_geometry(self) -> None:
+        if not self.frame.isVisible() and not self.title_label.text():
+            return
+
+        target_rect = self.target.rect()
+        margin = 24
+        max_width = max(160, min(420, target_rect.width() - (2 * margin)))
+        self.frame.setMaximumWidth(max_width)
+        self.frame.adjustSize()
+
+        size = self.frame.sizeHint()
+        width = min(max_width, max(160, size.width()))
+        height = size.height()
+        x = target_rect.left() + max(margin, (target_rect.width() - width) // 2)
+        y = target_rect.top() + max(margin, (target_rect.height() - height) // 2)
+        self.frame.setGeometry(x, y, width, height)

qplot/windows/_plot_status.py

@@ -0,0 +1,115 @@
+"""Compact, persistent feedback for the refresh toolbar."""
+
+from datetime import datetime
+
+from PyQt6 import QtCore, QtGui
+from PyQt6 import QtWidgets as qtw
+
+
+class _StatusLabel(qtw.QLabel):
+    def minimumSizeHint(self):
+        return QtCore.QSize(0, super().minimumSizeHint().height())
+
+    def paintEvent(self, event):
+        painter = QtGui.QPainter(self)
+        self.style().drawItemText(
+            painter, self.contentsRect(),
+            QtCore.Qt.AlignmentFlag.AlignRight | QtCore.Qt.AlignmentFlag.AlignVCenter,
+            self.palette(), self.isEnabled(),
+            self.fontMetrics().elidedText(
+                self.text(), QtCore.Qt.TextElideMode.ElideRight, self.contentsRect().width(),
+            ),
+            QtGui.QPalette.ColorRole.WindowText,
+        )
+
+
+class PlotStatusWidget(qtw.QWidget):
+    """Use the available toolbar space for a message or current-stage progress."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setObjectName("plotToolbarStatus")
+        self.setSizePolicy(qtw.QSizePolicy.Policy.Expanding, qtw.QSizePolicy.Policy.Preferred)
+        self.message = ""
+        self._progress_active = False
+
+        self.status_label = _StatusLabel(self)
+        self.status_label.setObjectName("plotStatusMessage")
+        self.status_label.setTextFormat(QtCore.Qt.TextFormat.PlainText)
+        self.status_label.setAccessibleName("Plot status")
+        self.status_label.setSizePolicy(qtw.QSizePolicy.Policy.Ignored, qtw.QSizePolicy.Policy.Preferred)
+
+        self.progress_panel = qtw.QWidget(self)
+        row = qtw.QHBoxLayout(self.progress_panel)
+        row.setContentsMargins(0, 0, 0, 0)
+        row.setSpacing(8)
+        self.progress_bar = qtw.QProgressBar(self.progress_panel)
+        self.progress_bar.setAccessibleName("Plot loading progress for the current stage")
+        self.progress_bar.setMinimumWidth(40)
+        self.progress_bar.setMaximumWidth(240)
+        self.progress_bar.setFormat("%p%")
+        self.elapsed_label = qtw.QLabel(self.progress_panel)
+        self.elapsed_label.setAccessibleName("Elapsed plot loading time")
+        self.stage_label = qtw.QLabel(self.progress_panel)
+        row.addStretch()
+        row.addWidget(self.progress_bar, 1)
+        row.addWidget(self.elapsed_label)
+        row.addWidget(self.stage_label)
+
+        self.stack = qtw.QStackedLayout()
+        # QStackedLayout fills its geometry without applying content margins.
+        # An outer layout reserves real space beside both status views.
+        layout = qtw.QHBoxLayout(self)
+        layout.setContentsMargins(12, 0, 16, 0)
+        layout.addLayout(self.stack)
+        # Long status text must not enlarge the toolbar or hide its controls.
+        self.stack.setSizeConstraint(qtw.QLayout.SizeConstraint.SetNoConstraint)
+        layout.setSizeConstraint(qtw.QLayout.SizeConstraint.SetNoConstraint)
+        self.stack.addWidget(self.status_label)
+        self.stack.addWidget(self.progress_panel)
+
+    def minimumSizeHint(self):
+        return QtCore.QSize(0, self.stack.minimumSize().height())
+
+    def sizeHint(self):
+        return QtCore.QSize(320, self.stack.sizeHint().height())
+
+    def show_message(self, message: str) -> None:
+        self.message = message
+        self.status_label.setText(message)
+        if message:
+            created_at = datetime.now().astimezone().strftime("%Y-%m-%d %H:%M:%S %Z")
+            self.status_label.setToolTip(f"{message}\nCreated: {created_at}")
+        else:
+            self.status_label.setToolTip("")
+        self.stack.setCurrentWidget(self.status_label)
+
+    def start_progress(self) -> None:
+        # Never restore an earlier operation's message when this load ends.
+        self.message = ""
+        self._progress_active = True
+        self.show_progress()
+
+    def show_progress(self) -> None:
+        self.stack.setCurrentWidget(self.progress_panel)
+
+    def finish_progress(self) -> None:
+        if self._progress_active:
+            self._progress_active = False
+            if self.message:
+                # Restore the message with its original creation timestamp.
+                self.stack.setCurrentWidget(self.status_label)
+            else:
+                self.show_message("Plot load complete.")
+
+    def set_progress_details(self, progress, context: str) -> None:
+        self.stage_label.setText(f"Stage {progress.stage}/2")
+        details = f"{context}\n{progress.title}\n"
+        if progress.total is not None and progress.total > 0:
+            details += f"{progress.completed:,} / {progress.total:,} ({progress.unit})\n"
+        details += (
+            "Progress is for the current stage. Scan progress covers the captured "
+            "source range, including partial array records."
+        )
+        self.progress_panel.setToolTip(details)
+        self.progress_bar.setAccessibleDescription(details)

qplot/windows/_plot_tiling.py

@@ -0,0 +1,35 @@
+"""Shared preferences and geometry for newly opened plot windows."""
+
+PLOT_TILE_ROWS_KEY = "user_preference.plot_tile_rows"
+PLOT_TILE_COLUMNS_KEY = "user_preference.plot_tile_columns"
+
+
+def plot_tile_grid(config):
+    """Return the configured (rows, columns) grid."""
+    return config.get(PLOT_TILE_ROWS_KEY), config.get(PLOT_TILE_COLUMNS_KEY)
+
+
+def plot_tile_size(config, screenrect):
+    """Size plots to their grid cells, retaining the configured frame margin."""
+    rows, columns = plot_tile_grid(config)
+    fraction = min(1.0, 2 * config.get("GUI.plot_frame_fraction"))
+    return (
+        max(1, int(fraction * screenrect.width() / columns)),
+        max(1, int(fraction * screenrect.height() / rows)),
+    )
+
+
+def place_plot_window(owner, window):
+    """Fill grid cells in row order and wrap; restart when the grid changes."""
+    grid = plot_tile_grid(owner.config)
+    if getattr(owner, "_plot_tile_grid", None) != grid:
+        owner._plot_tile_grid = grid
+        owner._next_plot_tile = 0
+    rows, columns = grid
+    row, column = divmod(owner._next_plot_tile, columns)
+    rect = owner.screenrect
+    window.move(
+        rect.left() + column * rect.width() // columns,
+        rect.top() + row * rect.height() // rows,
+    )
+    owner._next_plot_tile = (owner._next_plot_tile + 1) % (rows * columns)

qplot/windows/_plot_transform_labels.py

@@ -0,0 +1,60 @@
+"""Display quantities for PyQtGraph's native PlotDataItem mappings.
+
+Input parameters describe samples after qPlot operations. These immutable
+descriptions never replace measurement or operation metadata.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class AxisQuantity:
+    label: str
+    unit: str
+
+    @classmethod
+    def from_parameter(cls, parameter: Any) -> "AxisQuantity":
+        return cls(
+            str(getattr(parameter, "label", None) or getattr(parameter, "name", "")),
+            str(getattr(parameter, "unit", "") or ""),
+        )
+
+
+def _unit_operand(unit: str) -> str:
+    return f"({unit})" if any(char in unit for char in "/ *") else unit
+
+
+def _quotient_unit(numerator: str, denominator: str) -> str:
+    if not denominator:
+        return numerator
+    return f"{_unit_operand(numerator) if numerator else '1'}/{_unit_operand(denominator)}"
+
+
+def native_axis_quantities(
+        x_parameter: Any, y_parameter: Any, options: dict[str, Any],
+        ) -> dict[str, AxisQuantity]:
+    """Mirror native mapping order, including mappings that reset to input.
+
+    PyQtGraph 0.14 subtracts the mean, then computes abs(rfft(y)/N).
+    Derivative mode replaces Y with diff(input Y)/diff(input X), retaining
+    the current X. Phase-map mode replaces both coordinates with input Y
+    and its derivative. Log ticking still describes these physical quantities.
+    """
+    input_x = AxisQuantity.from_parameter(x_parameter)
+    input_y = AxisQuantity.from_parameter(y_parameter)
+    x, y = input_x, input_y
+    if options.get("subtractMeanMode"):
+        y = AxisQuantity(f"{y.label} - mean({y.label})", y.unit)
+    if options.get("fftMode"):
+        x = AxisQuantity(f"Frequency of {input_x.label}", _quotient_unit("", input_x.unit))
+        fft_input = f"({y.label})" if options.get("subtractMeanMode") else y.label
+        y = AxisQuantity(f"FFT magnitude of {fft_input}", y.unit)
+    if options.get("derivativeMode") or options.get("phasemapMode"):
+        y = AxisQuantity(
+            f"d({input_y.label})/d({input_x.label})",
+            _quotient_unit(input_y.unit, input_x.unit),
+        )
+    if options.get("phasemapMode"):
+        x = input_y
+    return {"x": x, "y": y}