gratinglab 0.1.4__tar.gz → 0.1.5__tar.gz

{gratinglab-0.1.4/src/gratinglab.egg-info → gratinglab-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gratinglab
-Version: 0.1.4
+Version: 0.1.5
 Summary: Open platform for diffraction grating groove metrology and efficiency analysis
 Author: Jake McCoy
 License: BSD-3-Clause
@@ -98,7 +98,8 @@ contributed and not yet integrated.
 
 Two halves. **Metrology** (`gratinglab.metrology`) reads AFM scans (Nanoscope `.spm`
 or Gwyddion text exports) and produces blaze angles per groove with row-group
-statistics and an ICC correction, plus one averaged groove normalised to a period.
+statistics and an ICC correction, plus one averaged groove normalised to a period,
+and swath statistics for how much that groove varies down the scan.
 Tip convolution can be undone where the tip reached the surface, and the region it
 never reached is marked rather than smoothed over. **Efficiency** is everything else:
 the problem spec, the solvers, the comparison and convergence harnesses, the materials

{gratinglab-0.1.4 → gratinglab-0.1.5}/README.md

@@ -59,7 +59,8 @@ contributed and not yet integrated.
 
 Two halves. **Metrology** (`gratinglab.metrology`) reads AFM scans (Nanoscope `.spm`
 or Gwyddion text exports) and produces blaze angles per groove with row-group
-statistics and an ICC correction, plus one averaged groove normalised to a period.
+statistics and an ICC correction, plus one averaged groove normalised to a period,
+and swath statistics for how much that groove varies down the scan.
 Tip convolution can be undone where the tip reached the surface, and the region it
 never reached is marked rather than smoothed over. **Efficiency** is everything else:
 the problem spec, the solvers, the comparison and convergence harnesses, the materials

{gratinglab-0.1.4 → gratinglab-0.1.5}/src/gratinglab/__init__.py

@@ -21,7 +21,7 @@ from .illumination import Illumination, Polarization
 from .resolution import ResolvingPower, resolving_power
 from .result import EfficiencyScan, OrderEfficiency, Provenance
 
-__version__ = "0.1.4"
+__version__ = "0.1.5"
 
 __all__ = [
     "Illumination",

{gratinglab-0.1.4 → gratinglab-0.1.5}/src/gratinglab/metrology/boundary/__init__.py

@@ -10,6 +10,7 @@ with the blaze-angle analysis in gratinglab.metrology.core.
 """
 
 from .pipeline import BoundaryProfile, build_boundary_profile
+from .swaths import SwathStatistics, swath_statistics
 from .average import (
     flatten_endpoints,
     average_grooves,
@@ -20,6 +21,8 @@ from .average import (
 __all__ = [
     'BoundaryProfile',
     'build_boundary_profile',
+    'SwathStatistics',
+    'swath_statistics',
     'flatten_endpoints',
     'average_grooves',
     'normalize_profile',

gratinglab-0.1.5/src/gratinglab/metrology/boundary/swaths.py

@@ -0,0 +1,259 @@
+"""Groove shape statistics across swaths: how much the shape varies down a scan.
+
+The boundary profile averages every row of a scan into one trace and every
+groove along it into one shape. That answers "what does the groove look like"
+and hides "how much does it vary". This module answers the second by building
+the same averaged groove separately for each swath (the horizontal row bands
+the blaze-angle analysis calls row groups, with exactly its banding) and
+comparing them.
+
+Two spreads come out, and the comparison between them is the point:
+
+``between_rms_nm``
+    How much the averaged groove differs from swath to swath: variation *down*
+    the image, along the length of the grooves.
+``within_rms_nm``
+    How much individual grooves differ from their swath's average: variation
+    *along* the scan line, groove to groove.
+
+A between-swath spread well above the within-swath one says the shape changes
+along the grooves (a ruling or etch gradient, or a drifting scan); the reverse
+says the grooves differ from each other more than any one groove changes along
+its length.
+
+Each swath's groove is aligned to the others by a circular shift before it is
+compared, so a groove that is the same shape but displaced counts
+as the same shape. Normalisation already rolls every groove so its minimum
+sits at the boundary, so that alignment only removes what is left over. The
+lateral position is measured separately, from where each swath finds its
+grooves, and reported as ``shift_nm``: a steady drift down the image is a fact
+about the scan (the grooves rotated relative to the fast axis, or thermal
+drift) and should not be mistaken for a shape change.
+
+Swaths are not independent samples: they re-measure the same grooves, so a
+spread here describes variation along the grooves, not the uncertainty of a
+mean. The blaze-angle row groups carry the same caveat and correct for it;
+see the ``icc-correction`` wiki page. The ``swath-statistics`` page is the
+reader's guide to everything here.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import io
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import numpy as np
+
+from ..core.processing import raw_data_multi_group
+from .pipeline import BoundaryProfile, build_boundary_profile
+
+__all__ = ["SwathStatistics", "swath_statistics"]
+
+#: Per-swath scalars reported, from each swath's profile metrics.
+METRICS = ("groove_depth", "peak_to_valley", "max_angle_deg", "rms_slope", "max_curvature")
+
+
+@dataclass(frozen=True)
+class SwathStatistics:
+    """The averaged groove of each swath, aligned, and how much they differ."""
+
+    #: The common axis, fractions of one period, and the whole-scan profile the
+    #: swaths were aligned to.
+    t: np.ndarray
+    whole: BoundaryProfile
+    #: One row per swath that produced a profile, aligned to one another.
+    profiles: np.ndarray
+    #: (first row, end row) of each of those swaths, in scan rows.
+    row_ranges: list
+    #: Lateral offset of each swath's groove from the whole-scan one, nm.
+    shift_nm: np.ndarray
+    #: Per-swath scalars and counts, one dict per swath.
+    per_swath: list
+    #: Swaths that produced no profile, as ((first, end), reason).
+    skipped: list = field(default_factory=list)
+
+    @property
+    def n_swaths(self) -> int:
+        return len(self.profiles)
+
+    @property
+    def mean(self) -> np.ndarray:
+        return self.profiles.mean(axis=0)
+
+    @property
+    def std(self) -> np.ndarray:
+        """Pointwise spread across swaths, fractions of the period."""
+        return self.profiles.std(axis=0, ddof=1) if self.n_swaths > 1 else np.zeros_like(self.t)
+
+    @property
+    def between_rms_nm(self) -> float:
+        """Swath-to-swath shape spread, RMS over the period, nm."""
+        return float(np.sqrt(np.mean(self.std ** 2)) * self.whole.period_nm)
+
+    @property
+    def within_rms_nm(self) -> float:
+        """Groove-to-groove spread within a swath, RMS over the period, averaged over swaths, nm."""
+        values = [s["within_rms_nm"] for s in self.per_swath]
+        return float(np.mean(values)) if values else float("nan")
+
+    @property
+    def whole_vs_swaths_rms_nm(self) -> float:
+        """How far the whole-scan groove sits from the swaths' mean, RMS, nm.
+
+        Large when the grooves drift sideways down the image: averaging every
+        row then blurs the shape, so the whole-scan groove, the one exported,
+        is rounder than any swath. Compare with ``shift_nm``.
+        """
+        mean = self.mean[:-1]
+        whole, _ = _align(self.whole.y_norm[:-1], mean)
+        return float(np.sqrt(np.mean((whole - mean) ** 2)) * self.whole.period_nm)
+
+    def metric_summary(self) -> dict:
+        """mean, std, min and max of each per-swath scalar."""
+        out = {}
+        for name in METRICS + ("period_nm",):
+            values = np.array([s[name] for s in self.per_swath], dtype=float)
+            out[name] = {
+                "mean": float(values.mean()),
+                "std": float(values.std(ddof=1)) if len(values) > 1 else 0.0,
+                "min": float(values.min()),
+                "max": float(values.max()),
+            }
+        return out
+
+    def summary(self) -> str:
+        """A few lines for a panel or a log."""
+        m = self.metric_summary()
+        lines = [
+            f"{self.n_swaths} swaths" + (f" ({len(self.skipped)} skipped)" if self.skipped else ""),
+            f"Shape spread between swaths : {self.between_rms_nm:.2f} nm RMS",
+            f"Groove-to-groove within one : {self.within_rms_nm:.2f} nm RMS",
+            f"Whole scan vs swath mean    : {self.whole_vs_swaths_rms_nm:.2f} nm RMS",
+            f"Depth        : {m['groove_depth']['mean']:.4f} +/- {m['groove_depth']['std']:.4f} of period",
+            f"Max sidewall : {m['max_angle_deg']['mean']:.2f} +/- {m['max_angle_deg']['std']:.2f} deg",
+            f"Period       : {m['period_nm']['mean']:.2f} +/- {m['period_nm']['std']:.2f} nm",
+            f"Lateral drift: {np.ptp(self.shift_nm):.1f} nm across the swaths",
+        ]
+        return "\n".join(lines)
+
+    def write_csv(self, path) -> Path:
+        """One row per swath: rows, shift, counts and scalars, under # comment lines."""
+        path = Path(path)
+        columns = ["first_row", "end_row", "shift_nm", "n_grooves_used", "period_nm",
+                   "within_rms_nm", *METRICS]
+        lines = [",".join(columns),
+                 f"# between-swath shape spread: {self.between_rms_nm!r} nm RMS",
+                 f"# within-swath groove-to-groove spread: {self.within_rms_nm!r} nm RMS",
+                 f"# whole-scan groove vs swath mean: {self.whole_vs_swaths_rms_nm!r} nm RMS",
+                 "# swaths re-measure the same grooves, so these describe variation, not independent samples"]
+        for (first, end), shift, s in zip(self.row_ranges, self.shift_nm, self.per_swath):
+            values = [first, end, float(shift), s["n_used"], s["period_nm"], s["within_rms_nm"],
+                      *(s[name] for name in METRICS)]
+            lines.append(",".join(repr(v) if isinstance(v, float) else str(v) for v in values))
+        path.write_bytes(("\n".join(lines) + "\n").encode("utf-8"))
+        return path
+
+
+def swath_statistics(data, scan_x_size, settings, n_swaths=None) -> SwathStatistics:
+    """Build the averaged groove for each swath of ``data`` and compare them.
+
+    Parameters:
+        data: 2-D height array in metres, image-flattened by the caller, the
+            same input ``build_boundary_profile`` takes.
+        scan_x_size: scan width in microns.
+        settings: AnalysisSettings, applied to each swath exactly as to the
+            whole scan (tip correction, edge exclusion, the ggp_* fields).
+        n_swaths: how many bands; defaults to ``settings.n_row_groups``. Bands
+            are at least 3 rows, so a short scan gets fewer, as with the
+            blaze-angle row groups whose banding this reuses.
+
+    Raises:
+        ValueError if the whole scan gives no profile, or fewer than two swaths
+        do, since there is then nothing to compare.
+    """
+    n = settings.n_row_groups if n_swaths is None else int(n_swaths)
+    whole = build_boundary_profile(data, scan_x_size, settings)
+    reference = whole.y_norm[:-1]  # closed profile: the last point repeats the first
+
+    with contextlib.redirect_stdout(io.StringIO()):  # it narrates its banding
+        _, _, info = raw_data_multi_group(data, scan_x_size, n_groups=n)
+
+    whole_phase = _groove_phase(whole)
+    profiles, ranges, phases, per_swath, skipped = [], [], [], [], []
+    for first, end in info["group_ranges"]:
+        try:
+            swath = build_boundary_profile(data[first:end, :], scan_x_size, settings)
+        except ValueError as exc:
+            skipped.append(((first, end), str(exc)))
+            continue
+        if len(swath.y_norm) != len(whole.y_norm):
+            skipped.append(((first, end), "profile length differs from the whole scan's"))
+            continue
+        aligned, _ = _align(swath.y_norm[:-1], reference)
+        profiles.append(np.append(aligned, aligned[0]))
+        ranges.append((first, end))
+        phases.append(_groove_phase(swath) - whole_phase)
+        per_swath.append({
+            **{name: float(swath.metrics[name]) for name in METRICS},
+            "period_nm": float(swath.period_nm),
+            "n_used": int(swath.n_used),
+            "within_rms_nm": float(np.sqrt(np.mean(np.asarray(swath.y_std_nm) ** 2))),
+        })
+
+    if len(profiles) < 2:
+        raise ValueError(
+            f"only {len(profiles)} of {len(info['group_ranges'])} swaths produced a "
+            "groove profile, so there is nothing to compare; use fewer swaths")
+
+    # The whole-scan groove is only a first reference: if the grooves drift
+    # down the image, averaging every row blurs it, so it is rounder than any
+    # swath. Re-align to the swaths' own mean, then roll the set so that mean
+    # has its minimum at the boundary, the convention normalisation uses.
+    closed = np.array(profiles)
+    open_ = closed[:, :-1]
+    for _ in range(2):
+        target = open_.mean(axis=0)
+        open_ = np.array([_align(y, target)[0] for y in open_])
+    open_ = np.roll(open_, -int(np.argmin(open_.mean(axis=0))), axis=1)
+    profiles = np.hstack([open_, open_[:, :1]])
+
+    return SwathStatistics(
+        t=whole.x_norm,
+        whole=whole,
+        profiles=profiles,
+        row_ranges=ranges,
+        # Unwrapped down the scan, so a drift past half a period reads as a
+        # trend rather than jumping back.
+        shift_nm=np.unwrap(np.array(phases)) / (2 * np.pi) * whole.period_nm,
+        per_swath=per_swath,
+        skipped=skipped,
+    )
+
+
+def _align(y: np.ndarray, reference: np.ndarray) -> tuple[np.ndarray, int]:
+    """Circularly shift ``y`` onto ``reference``; return it and the signed shift.
+
+    The shift minimising the squared difference is the one maximising the
+    circular cross-correlation, found by FFT. Signed, so a drift down the
+    image reads as a trend rather than wrapping.
+    """
+    a = y - y.mean()
+    b = reference - reference.mean()
+    correlation = np.fft.irfft(np.fft.rfft(b) * np.conj(np.fft.rfft(a)), n=len(a))
+    k = int(np.argmax(correlation))
+    if k > len(a) // 2:
+        k -= len(a)
+    return np.roll(y, k), k
+
+
+def _groove_phase(profile: BoundaryProfile) -> float:
+    """Where the grooves sit along the scan line, as a phase of the period.
+
+    The circular mean of the groove centres, so it needs no matching of one
+    swath's grooves to another's and does not care which grooves the edge
+    exclusion dropped.
+    """
+    x_nm = np.asarray(profile.profile_x_um)[np.asarray(profile.groove_centers)] * 1000.0
+    return float(np.angle(np.mean(np.exp(2j * np.pi * x_nm / profile.period_nm))))

{gratinglab-0.1.4 → gratinglab-0.1.5}/src/gratinglab/metrology/gui/qt/boundary_view.py

@@ -164,6 +164,14 @@ class BoundaryView(QWidget):
             "this scan measured already filled in.")
         self.send_btn.clicked.connect(self.send_to_efficiency)
         layout.addWidget(self.send_btn)
+
+        self.swaths_btn = QPushButton("Swath statistics…")
+        self.swaths_btn.setEnabled(False)
+        self.swaths_btn.setToolTip(
+            "Build the groove separately for each horizontal band of rows and "
+            "show how much the shape varies down the scan.")
+        self.swaths_btn.clicked.connect(self.show_swaths)
+        layout.addWidget(self.swaths_btn)
         self._efficiency_window = None
         return group
 
@@ -300,6 +308,7 @@ class BoundaryView(QWidget):
         self.export_btn.setEnabled(enabled)
         self.efficiency_btn.setEnabled(enabled)
         self.send_btn.setEnabled(enabled)
+        self.swaths_btn.setEnabled(enabled)
 
     # ── Out to a solver ──────────────────────────────────────────────────────
 
@@ -319,6 +328,21 @@ class BoundaryView(QWidget):
 
         EfficiencyDialog(self._profile, self).exec()
 
+    def swath_dialog(self):
+        """A SwathDialog for the current scan and settings, or None."""
+        if self._profile is None:
+            return None
+        from .swath_dialog import SwathDialog
+
+        settings = self._settings.with_(**self.settings_overrides())
+        return SwathDialog(self._data, self._scan_size, settings, self._filename, self)
+
+    def show_swaths(self):
+        """How much the groove varies from swath to swath down the scan."""
+        dialog = self.swath_dialog()
+        if dialog is not None:
+            dialog.exec()
+
     # ── Export ───────────────────────────────────────────────────────────────
 
     #: File-dialog filters, and the suffix each one writes.

gratinglab-0.1.5/src/gratinglab/metrology/gui/qt/swath_dialog.py

@@ -0,0 +1,161 @@
+"""
+How much the averaged groove varies from swath to swath down the scan.
+
+Opened from the Boundary tab. The tab averages every row into one groove; this
+splits the rows into swaths, the same bands the blaze-angle analysis calls row
+groups, builds the groove for each, and shows how far they disagree.
+
+Computation lives in ``gratinglab.metrology.boundary.swath_statistics``.
+"""
+from __future__ import annotations
+
+import os
+
+from . import *  # noqa: F401,F403 - sets QT_API before matplotlib's shim loads
+
+import numpy as np
+from PySide6.QtWidgets import (
+    QDialog, QFileDialog, QHBoxLayout, QLabel, QMessageBox, QPushButton,
+    QSpinBox, QVBoxLayout, QWidget,
+)
+from matplotlib import colormaps
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+
+from ...boundary import swath_statistics
+from ...config import RESULTS_DIR
+
+__all__ = ["SwathDialog"]
+
+
+class SwathDialog(QDialog):
+    """Per-swath groove shapes, their spread, and the scalars down the scan."""
+
+    def __init__(self, data, scan_size, settings, filename=None,
+                 parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._data = data
+        self._scan_size = scan_size
+        self._settings = settings
+        self._filename = filename
+        self._stats = None
+
+        self.setWindowTitle("Groove shape across swaths")
+        self.resize(980, 640)
+        self._build_ui()
+        self.recompute()
+
+    def _build_ui(self):
+        root = QHBoxLayout(self)
+        root.setContentsMargins(8, 8, 8, 8)
+
+        left = QWidget()
+        left.setFixedWidth(300)
+        column = QVBoxLayout(left)
+        column.setContentsMargins(0, 0, 0, 0)
+
+        row = QHBoxLayout()
+        row.addWidget(QLabel("Swaths:"))
+        self.n_spin = QSpinBox()
+        self.n_spin.setRange(2, 100)
+        self.n_spin.setValue(max(2, int(self._settings.n_row_groups)))
+        self.n_spin.setToolTip(
+            "Horizontal bands of rows, each averaged into its own groove. "
+            "At least 3 rows each, so a short scan gets fewer.")
+        self.n_spin.valueChanged.connect(self.recompute)
+        row.addWidget(self.n_spin)
+        column.addLayout(row)
+
+        self.summary_label = QLabel("")
+        self.summary_label.setWordWrap(True)
+        self.summary_label.setStyleSheet("font-family: monospace; font-size: 11px;")
+        column.addWidget(self.summary_label)
+
+        note = QLabel(
+            "Between swaths: how much the groove changes along its length, down "
+            "the image. Within one: how much grooves differ side by side. "
+            "Swaths re-measure the same grooves, so these describe variation, "
+            "not independent samples.")
+        note.setWordWrap(True)
+        note.setStyleSheet("font-size: 11px; color: gray;")
+        column.addWidget(note)
+
+        self.export_btn = QPushButton("Export per-swath CSV…")
+        self.export_btn.clicked.connect(self.export)
+        column.addWidget(self.export_btn)
+        column.addStretch(1)
+        root.addWidget(left)
+
+        self.figure = Figure(figsize=(7, 6), layout="constrained")
+        self.canvas = FigureCanvas(self.figure)
+        root.addWidget(self.canvas, stretch=1)
+
+    @property
+    def stats(self):
+        """The current SwathStatistics, or None if the scan gave too few swaths."""
+        return self._stats
+
+    def recompute(self):
+        try:
+            self._stats = swath_statistics(
+                self._data, self._scan_size, self._settings, n_swaths=self.n_spin.value())
+        except ValueError as exc:
+            self._stats = None
+            self.export_btn.setEnabled(False)
+            self.summary_label.setText(f"No swath statistics:\n{exc}")
+            self.figure.clear()
+            self.canvas.draw()
+            return
+        self.export_btn.setEnabled(True)
+        text = self._stats.summary()
+        if self._stats.skipped:
+            text += "\n\nSkipped rows " + ", ".join(
+                f"{a}-{b - 1}" for (a, b), _ in self._stats.skipped)
+        self.summary_label.setText(text)
+        self._draw()
+
+    def _draw(self):
+        s = self._stats
+        self.figure.clear()
+        grid = self.figure.add_gridspec(2, 3, height_ratios=[1.6, 1])
+        shapes = self.figure.add_subplot(grid[0, :])
+        colours = colormaps["viridis"](np.linspace(0.0, 0.9, s.n_swaths))
+        for profile, colour, (first, end) in zip(s.profiles, colours, s.row_ranges):
+            shapes.plot(s.t, profile, color=colour, lw=0.8, alpha=0.8)
+        shapes.fill_between(s.t, s.mean - 2 * s.std, s.mean + 2 * s.std,
+                            color="0.6", alpha=0.35, lw=0, label="±2σ between swaths")
+        shapes.plot(s.t, s.whole.y_norm, color="k", lw=1.4, ls="--", label="whole scan")
+        shapes.set_xlabel("position (fraction of period)")
+        shapes.set_ylabel("height (fraction of period)")
+        shapes.set_title(f"{s.n_swaths} swaths, coloured top to bottom of the scan")
+        shapes.legend(loc="best", fontsize=8)
+
+        centre = [(a + b - 1) / 2 for a, b in s.row_ranges]
+        panels = (
+            ("groove_depth", "depth (frac. of period)"),
+            ("max_angle_deg", "max sidewall (deg)"),
+        )
+        for i, (key, label) in enumerate(panels):
+            ax = self.figure.add_subplot(grid[1, i])
+            ax.plot(centre, [p[key] for p in s.per_swath], "o-", ms=3)
+            ax.set_xlabel("scan row")
+            ax.set_ylabel(label)
+        ax = self.figure.add_subplot(grid[1, 2])
+        ax.plot(centre, s.shift_nm, "o-", ms=3)
+        ax.set_xlabel("scan row")
+        ax.set_ylabel("lateral shift (nm)")
+        self.canvas.draw()
+
+    def export(self):
+        if self._stats is None:
+            return
+        stem = os.path.splitext(os.path.basename(self._filename or "scan"))[0]
+        start = os.path.join(str(RESULTS_DIR), f"{stem}_swaths.csv")
+        path, _ = QFileDialog.getSaveFileName(
+            self, "Export per-swath statistics", start, "CSV table (*.csv)")
+        if not path:
+            return
+        try:
+            self._stats.write_csv(path)
+        except OSError as exc:
+            QMessageBox.critical(self, "Export failed", str(exc))

{gratinglab-0.1.4 → gratinglab-0.1.5}/src/gratinglab/metrology/wiki/__init__.py

@@ -31,6 +31,7 @@ PAGE_ORDER = (
     "tip-correction",
     "row-groups",
     "icc-correction",
+    "swath-statistics",
     "facet-fitting",
     "reading-outputs",
 )

gratinglab-0.1.5/src/gratinglab/metrology/wiki/swath-statistics.md

@@ -0,0 +1,61 @@
+# Swath statistics
+
+The boundary profile averages every row of the scan into one trace, and every
+groove along that trace into one shape. That is the right thing to export, and
+it hides how much the groove varies. **Swath statistics** builds the same
+averaged groove separately for each horizontal band of rows (the same bands the
+blaze-angle analysis calls row groups) and compares them.
+
+In the metrology window: load a scan, open the **Boundary** tab and press
+**Swath statistics…**. The dialog uses the Boundary tab's settings and the tip
+correction, so each swath is built exactly as the exported profile is. The
+swath count starts at the row-group count and can be changed there.
+
+## The two spreads
+
+| Number | Means |
+|---|---|
+| Shape spread between swaths | How much the averaged groove changes **down the image**, along the length of the grooves. RMS over the period, nm. |
+| Groove-to-groove within one | How much individual grooves differ **side by side**, from their swath's average. |
+| Whole scan vs swath mean | How far the exported whole-scan groove sits from the swaths' mean. |
+
+A between-swath spread well above the within-swath one says the shape changes
+along the grooves: a ruling or etch gradient, or a scan that changed as it went.
+The reverse says the grooves differ from one another more than any one groove
+changes along its length.
+
+## Drift, and why the exported groove can be rounder than every swath
+
+Each swath's groove is aligned to the others before they are compared, so a
+groove that has the same shape but sits a little to one side counts as the same
+shape. The sideways position is reported separately as **lateral shift**,
+measured from where each swath finds its grooves.
+
+A steady shift down the image means the grooves are not parallel to the slow
+scan axis (the sample is rotated slightly) or the scan drifted thermally. It
+matters for the export: the whole-scan profile averages rows whose grooves sit
+in different places, so it **blurs** the shape. On the synthetic grating, 20 nm
+of drift across the scan makes the whole-scan groove depth read about 5% low,
+while every swath reads correctly. That is what **Whole scan vs swath mean**
+catches. If it is large and the shift plot is a slope, rotate the image or scan
+before trusting the exported depth and angles.
+
+## Not independent samples
+
+Swaths re-measure the same grooves, so their spread describes how the groove
+varies, not the uncertainty of a mean. Do not divide it by the square root of
+the swath count. The blaze-angle row groups have the same problem and correct
+for it; see the ICC correction page.
+
+## Export
+
+**Export per-swath CSV…** writes one row per swath: its rows, lateral shift,
+grooves used, period, groove-to-groove spread and the profile metrics, with the
+three spreads above as `#` comment lines under the header. From Python:
+
+```python
+from gratinglab.metrology.boundary import swath_statistics
+stats = swath_statistics(data, scan_x_um, settings, n_swaths=8)
+print(stats.summary())
+stats.write_csv("swaths.csv")
+```

{gratinglab-0.1.4 → gratinglab-0.1.5/src/gratinglab.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gratinglab
-Version: 0.1.4
+Version: 0.1.5
 Summary: Open platform for diffraction grating groove metrology and efficiency analysis
 Author: Jake McCoy
 License: BSD-3-Clause
@@ -98,7 +98,8 @@ contributed and not yet integrated.
 
 Two halves. **Metrology** (`gratinglab.metrology`) reads AFM scans (Nanoscope `.spm`
 or Gwyddion text exports) and produces blaze angles per groove with row-group
-statistics and an ICC correction, plus one averaged groove normalised to a period.
+statistics and an ICC correction, plus one averaged groove normalised to a period,
+and swath statistics for how much that groove varies down the scan.
 Tip convolution can be undone where the tip reached the surface, and the region it
 never reached is marked rather than smoothed over. **Efficiency** is everything else:
 the problem spec, the solvers, the comparison and convergence harnesses, the materials

{gratinglab-0.1.4 → gratinglab-0.1.5}/src/gratinglab.egg-info/SOURCES.txt

@@ -61,6 +61,7 @@ src/gratinglab/metrology/workflows.py
 src/gratinglab/metrology/boundary/__init__.py
 src/gratinglab/metrology/boundary/average.py
 src/gratinglab/metrology/boundary/pipeline.py
+src/gratinglab/metrology/boundary/swaths.py
 src/gratinglab/metrology/core/__init__.py
 src/gratinglab/metrology/core/analysis.py
 src/gratinglab/metrology/core/image_flatten.py
@@ -78,6 +79,7 @@ src/gratinglab/metrology/gui/qt/canvas.py
 src/gratinglab/metrology/gui/qt/efficiency_dialog.py
 src/gratinglab/metrology/gui/qt/import_view.py
 src/gratinglab/metrology/gui/qt/main_window.py
+src/gratinglab/metrology/gui/qt/swath_dialog.py
 src/gratinglab/metrology/gui/qt/wiki_view.py
 src/gratinglab/metrology/gui/qt/worker.py
 src/gratinglab/metrology/io/__init__.py
@@ -99,6 +101,7 @@ src/gratinglab/metrology/wiki/icc-correction.md
 src/gratinglab/metrology/wiki/overview.md
 src/gratinglab/metrology/wiki/reading-outputs.md
 src/gratinglab/metrology/wiki/row-groups.md
+src/gratinglab/metrology/wiki/swath-statistics.md
 src/gratinglab/metrology/wiki/tip-correction.md
 src/gratinglab/solvers/__init__.py
 src/gratinglab/solvers/base.py