gnsskit 0.4.0__py3-none-any.whl

gnsskit/static/network.py

@@ -0,0 +1,448 @@
+"""Least-squares adjustment of a GNSS baseline network with fixed points.
+
+Notation (as in the course notebooks):
+    y = A x + b                  baselines  X_rover - X_base = dxyz, fixed points in b
+    y0 = y + v,  v ~ N(0, Q)     observations y0 (n values), parameters x (m values)
+    N = A^T Q^-1 A
+    X_hat = N^-1 A^T Q^-1 (y0 - b),   Y_hat = A X_hat + b,   v_hat = y0 - Y_hat
+    sigma_v_hat = v_hat^T Q^-1 v_hat / (n - m)            a-posteriori variance factor
+    Cxx = sigma_v_hat N^-1,  Cyy = sigma_v_hat A N^-1 A^T,  Cvv = sigma_v_hat (Q - A N^-1 A^T)
+
+Stochastic model of a baseline (`stochastic` argument of `adjust_network`):
+    "rtklib_scaled": formal RTKLIB covariance times a variance factor k_s (default, see K_S).
+    "rtklib":  formal covariance of the RTKLIB solution; optimistic (sigma_v_hat >> 1),
+               because RTKLIB treats the epochs as independent.
+    "apriori": east/north/up errors, uncorrelated, with sd = a + b[ppm] * length.
+
+Scaling Q by k_s leaves X_hat, Cxx, Cvv and tau unchanged and divides sigma_v_hat by k_s:
+only the global test depends on it.
+
+Layout: the stochastic model (Q) and the functional model (A, b) are built from the
+baselines, then `weighted_least_squares` solves the generic problem, which does not depend
+on GNSS and can be reused for other adjustments.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Literal
+
+import numpy as np
+import pandas as pd
+
+from ..refsys import ENUFrame, ecef_to_llh
+from .baseline import BaselineResult
+
+try:
+    from pyproj import Transformer
+    from scipy.stats import chi2
+except ImportError as e:  # pragma: no cover
+    raise ImportError(
+        "gnsskit.static.network needs the 'network' extra: pip install 'gnsskit[network]'"
+    ) from e
+
+# =============================================================================
+# Defaults and thresholds
+# =============================================================================
+
+# Default a-priori baseline precision as (constant [m], ppm of the length)
+SIGMA_H = (5e-3, 1.0)  # horizontal: 5 mm + 1 ppm
+SIGMA_V = (10e-3, 2.0)  # vertical: 10 mm + 2 ppm
+
+# Variance factor of the RTKLIB covariance for 5 s epochs. RTKLIB treats the epochs as independent; with errors correlated as exp(-dt / T), the variance of the mean is too small by (1 + rho) / (1 - rho) ~ 2 T / dt. T ~ 60 s (multipath at a static site), dt = 5 s -> 24.
+# For another interval use k_s ~ 2 * 60 / dt, e.g. 120 for 1 s, 8 for 15 s.
+K_S = 25.0
+
+# RTKLIB prints standard deviations rounded to 0.1 mm, which can make a 3x3 covariance matrix non-positive-definite; its eigenvalues are floored at this variance before inversion.
+MIN_VARIANCE = 1e-6**2  # m^2, (1 um)^2: far below any GNSS precision, touches only broken matrices
+
+TAU_CRITICAL = 3.29  # two-sided 0.1 % level of a standard normal (Baarda data snooping)
+
+
+# =============================================================================
+# Generic weighted least squares
+# =============================================================================
+
+
+@dataclass(frozen=True)
+class LsqSolution:
+    """Solution of y0 = A x + b + v, v ~ N(0, sigma^2 Q) (see the module docstring)."""
+
+    X_hat: np.ndarray  # (m,) estimated parameters
+    Y_hat: np.ndarray  # (n,) adjusted observations
+    v_hat: np.ndarray  # (n,) residuals
+    sigma_v_hat: float  # a-posteriori variance factor, expected ~1
+    Cxx: np.ndarray  # (m, m) covariance of the parameters
+    Cyy: np.ndarray  # (n, n) covariance of the adjusted observations
+    Cvv: np.ndarray  # (n, n) covariance of the residuals
+    R: np.ndarray  # (n, n) redundancy matrix, trace = n - m
+    tau: np.ndarray  # (n,) normalised residuals |v_i| / sd(v_i)
+
+
+def weighted_least_squares(
+    A: np.ndarray, Q: np.ndarray, y0: np.ndarray, b: np.ndarray | None = None
+) -> LsqSolution:
+    """Weighted least-squares solution of y0 = A x + b + v with observation covariance Q.
+
+    Args:
+        A: (n, m) design matrix, full column rank.
+        Q: (n, n) a-priori covariance of the observations (cofactor matrix).
+        y0: (n,) observations.
+        b: (n,) known terms. None for zeros.
+
+    Returns:
+        Estimates, their covariances scaled by the a-posteriori variance factor, the
+        redundancy matrix and the normalised residuals.
+    """
+    b = np.zeros_like(y0) if b is None else b
+    n, m = A.shape
+
+    Q_inv = np.linalg.inv(Q)  # weight matrix
+    N = A.T @ Q_inv @ A  # normal matrix
+    X_hat = np.linalg.solve(N, A.T @ Q_inv @ (y0 - b))
+    Y_hat = A @ X_hat + b
+    v_hat = y0 - Y_hat
+    sigma_v_hat = float(v_hat @ Q_inv @ v_hat / (n - m))
+
+    N_inv = np.linalg.inv(N)
+    Q_vv = Q - A @ N_inv @ A.T  # cofactor matrix of the residuals
+    Cvv = sigma_v_hat * Q_vv
+    return LsqSolution(
+        X_hat=X_hat,
+        Y_hat=Y_hat,
+        v_hat=v_hat,
+        sigma_v_hat=sigma_v_hat,
+        Cxx=sigma_v_hat * N_inv,
+        Cyy=sigma_v_hat * (A @ N_inv @ A.T),
+        Cvv=Cvv,
+        R=Q_vv @ Q_inv,
+        tau=np.abs(v_hat) / np.sqrt(np.maximum(np.diag(Cvv), 1e-30)),
+    )
+
+
+# =============================================================================
+# Network adjustment result
+# =============================================================================
+
+
+@dataclass(frozen=True)
+class Adjustment:
+    """Result of `adjust_network`. Observations are ordered baseline by baseline (dx, dy, dz),
+    parameters point by point (X, Y, Z), the points following `unknowns`."""
+
+    unknowns: list[str]  # adjusted (free) points
+    fixed: dict[str, np.ndarray]  # fixed points, ECEF m
+    baselines: list[BaselineResult]
+    y0: np.ndarray  # (n,) observations
+    b: np.ndarray  # (n,) known terms (fixed points)
+    A: np.ndarray  # (n, m) design matrix
+    Q: np.ndarray  # (n, n) covariance of the observations
+    X_hat: np.ndarray  # (m,) estimated coordinates
+    Y_hat: np.ndarray  # (n,) adjusted observations
+    v_hat: np.ndarray  # (n,) residuals
+    sigma_v_hat: float  # a-posteriori variance factor, expected ~1
+    Cxx: np.ndarray  # (m, m) covariance of the parameters
+    Cyy: np.ndarray  # (n, n) covariance of the adjusted observations
+    Cvv: np.ndarray  # (n, n) covariance of the residuals
+    R: np.ndarray  # (n, n) redundancy matrix, trace = n - m
+    tau: np.ndarray  # (n,) normalised residuals
+
+    @property
+    def n(self) -> int:
+        """Number of observations."""
+        return self.y0.size
+
+    @property
+    def m(self) -> int:
+        """Number of estimated parameters."""
+        return self.X_hat.size
+
+    @property
+    def dof(self) -> int:
+        """Degrees of freedom, n - m."""
+        return self.n - self.m
+
+    @property
+    def xyz(self) -> np.ndarray:
+        """(len(unknowns), 3) adjusted ECEF coordinates."""
+        return self.X_hat.reshape(-1, 3)
+
+    @property
+    def sigma_v_hat_bounds(self) -> tuple[float, float]:
+        """95 % acceptance interval of sigma_v_hat under the chi-square test."""
+        lo, hi = chi2.ppf([0.025, 0.975], self.dof) / self.dof
+        return float(lo), float(hi)
+
+
+# =============================================================================
+# Stochastic model: covariance Q of the baselines
+# =============================================================================
+
+
+def _make_pd(cov: np.ndarray) -> np.ndarray:
+    """Covariance with eigenvalues floored at MIN_VARIANCE; unchanged if already above it."""
+    w, vec = np.linalg.eigh(cov)
+    if w.min() >= MIN_VARIANCE:
+        return cov
+    return (vec * np.maximum(w, MIN_VARIANCE)) @ vec.T
+
+
+def _apriori_block(
+    length: float,
+    R_enu: np.ndarray,
+    sigma_h: tuple[float, float],
+    sigma_v: tuple[float, float],
+) -> np.ndarray:
+    """ECEF 3x3 covariance of a baseline: east/north/up errors a + b[ppm] * length."""
+    sd_h = sigma_h[0] + sigma_h[1] * 1e-6 * length
+    sd_v = sigma_v[0] + sigma_v[1] * 1e-6 * length
+    Q_enu = np.diag([sd_h**2, sd_h**2, sd_v**2])
+    return R_enu.T @ Q_enu @ R_enu
+
+
+def _observation_covariance(
+    baselines: Sequence[BaselineResult],
+    fixed: Mapping[str, np.ndarray],
+    stochastic: str,
+    sigma_h: tuple[float, float],
+    sigma_v: tuple[float, float],
+    k_s: float,
+) -> np.ndarray:
+    """Block-diagonal ECEF covariance Q of the observations, one 3x3 block per baseline.
+
+    "apriori" blocks are built in east, north, up and rotated to ECEF; the RTKLIB blocks are
+    already ECEF and only made positive definite (and scaled by `k_s` for "rtklib_scaled").
+    """
+    # One east-north-up rotation, taken at the first fixed point, serves a small network
+    R_enu = ENUFrame.from_ecef(next(iter(fixed.values()))).rotation
+
+    Q = np.zeros((3 * len(baselines),) * 2)
+    for k, bl in enumerate(baselines):
+        if stochastic == "apriori":
+            block = _apriori_block(bl.length, R_enu, sigma_h, sigma_v)
+        else:
+            block = _make_pd(bl.cov) * (k_s if stochastic == "rtklib_scaled" else 1.0)
+        Q[3 * k : 3 * k + 3, 3 * k : 3 * k + 3] = block
+    return Q
+
+
+# =============================================================================
+# Functional model: design matrix A and known terms b
+# =============================================================================
+
+
+def _design_matrix(
+    baselines: Sequence[BaselineResult],
+    unknowns: Sequence[str],
+    fixed: Mapping[str, np.ndarray],
+) -> tuple[np.ndarray, np.ndarray]:
+    """Design matrix A and known terms b of y = A x + b.
+
+    A has +I (3x3) in the columns of the rover and -I in those of the base. When the rover
+    or the base is a fixed point, its coordinates are moved to the known terms b.
+    """
+    col = {p: 3 * j for j, p in enumerate(unknowns)}
+    A = np.zeros((3 * len(baselines), 3 * len(unknowns)))
+    b = np.zeros(3 * len(baselines))
+    for k, bl in enumerate(baselines):
+        rows = slice(3 * k, 3 * k + 3)
+        for point, sign in ((bl.rover, +1), (bl.base, -1)):
+            if point in col:
+                A[rows, col[point] : col[point] + 3] = sign * np.eye(3)
+            else:
+                b[rows] += sign * fixed[point]
+    return A, b
+
+
+# =============================================================================
+# Network adjustment
+# =============================================================================
+
+
+def adjust_network(
+    baselines: Sequence[BaselineResult],
+    fixed: Mapping[str, Sequence[float] | np.ndarray],
+    stochastic: Literal["rtklib_scaled", "rtklib", "apriori"] = "rtklib_scaled",
+    sigma_h: tuple[float, float] = SIGMA_H,
+    sigma_v: tuple[float, float] = SIGMA_V,
+    k_s: float = K_S,
+) -> Adjustment:
+    """Weighted least squares of the baseline vectors with the `fixed` points held.
+
+    The default model is the RTKLIB covariance scaled by `k_s` = 25 (sd x 5), a value for
+    baselines processed at 5 s epochs: RTKLIB treats the epochs as independent, while real
+    errors are correlated over about a minute (see K_S). For another processing interval dt
+    use k_s ~ 120 / dt [s]. Choose k_s before looking at the network: setting it to the
+    sigma_v_hat of the "rtklib" model makes the global test meaningless.
+
+    Args:
+        baselines: Baselines (base -> rover vectors) forming the network.
+        fixed: Point name -> ECEF coordinates [m] of the held points.
+        stochastic: Baseline error model: "rtklib_scaled" (RTKLIB covariance x `k_s`), "rtklib" (formal RTKLIB covariance) or "apriori" (ENU errors from `sigma_h`/`sigma_v`); see the module docstring.
+        sigma_h: A-priori horizontal precision as (constant [m], ppm of the length). Used by the "apriori" model only.
+        sigma_v: A-priori vertical precision, same form. "apriori" only.
+        k_s: Variance factor of the RTKLIB covariance. "rtklib_scaled" only.
+
+    Returns:
+        The adjustment, with parameters for the points not in `fixed`.
+
+    Raises:
+        ValueError: If `stochastic` is not one of the three models.
+    """
+    if stochastic not in ("rtklib_scaled", "rtklib", "apriori"):
+        raise ValueError(
+            f"stochastic must be 'rtklib_scaled', 'rtklib' or 'apriori', not {stochastic!r}"
+        )
+    if stochastic == "rtklib_scaled":
+        print(
+            f"adjust_network: RTKLIB covariance x k_s = {k_s:g} (sd x {np.sqrt(k_s):.1f}); "
+            "k_s = 25 suits 5 s epochs, use k_s ~ 120 / dt[s] for another interval"
+        )
+    fixed_xyz = {p: np.asarray(x, dtype=float) for p, x in fixed.items()}
+    points = dict.fromkeys(p for bl in baselines for p in (bl.base, bl.rover))
+    unknowns = [p for p in points if p not in fixed_xyz]
+
+    y0 = np.concatenate([bl.dxyz for bl in baselines])
+    Q = _observation_covariance(baselines, fixed_xyz, stochastic, sigma_h, sigma_v, k_s)
+    A, b = _design_matrix(baselines, unknowns, fixed_xyz)
+    sol = weighted_least_squares(A, Q, y0, b)
+
+    return Adjustment(
+        unknowns=unknowns,
+        fixed=fixed_xyz,
+        baselines=list(baselines),
+        y0=y0,
+        b=b,
+        A=A,
+        Q=Q,
+        X_hat=sol.X_hat,
+        Y_hat=sol.Y_hat,
+        v_hat=sol.v_hat,
+        sigma_v_hat=sol.sigma_v_hat,
+        Cxx=sol.Cxx,
+        Cyy=sol.Cyy,
+        Cvv=sol.Cvv,
+        R=sol.R,
+        tau=sol.tau,
+    )
+
+
+# =============================================================================
+# Result tables: residuals and coordinates
+# =============================================================================
+
+
+def residual_table(adj: Adjustment) -> pd.DataFrame:
+    """Residuals, redundancy number and normalised residual of every baseline.
+
+    Args:
+        adj: Result of `adjust_network`.
+
+    Returns:
+        One row per baseline: session, base, rover, vx_mm, vy_mm, vz_mm [mm], redundancy,
+        tau (largest of the three normalised residuals) and outlier (tau > TAU_CRITICAL).
+    """
+    tau = adj.tau.reshape(-1, 3).max(axis=1)
+    return pd.DataFrame({
+        "session": [bl.session for bl in adj.baselines],
+        "base": [bl.base for bl in adj.baselines],
+        "rover": [bl.rover for bl in adj.baselines],
+        "vx_mm": adj.v_hat[0::3] * 1e3,
+        "vy_mm": adj.v_hat[1::3] * 1e3,
+        "vz_mm": adj.v_hat[2::3] * 1e3,
+        "redundancy": np.diag(adj.R).reshape(-1, 3).sum(axis=1),
+        "tau": tau,
+        "outlier": tau > TAU_CRITICAL,
+    })  # fmt: skip
+
+
+def ecef_table(adj: Adjustment) -> pd.DataFrame:
+    """Adjusted ECEF coordinates and standard deviations of the unknown points.
+
+    Args:
+        adj: Result of `adjust_network`.
+
+    Returns:
+        DataFrame indexed by point with X, Y, Z, sd_X, sd_Y, sd_Z [m].
+    """
+    sd = np.sqrt(np.diag(adj.Cxx))
+    return pd.DataFrame(
+        {
+            "point": adj.unknowns,
+            "X": adj.X_hat[0::3], "Y": adj.X_hat[1::3], "Z": adj.X_hat[2::3],
+            "sd_X": sd[0::3], "sd_Y": sd[1::3], "sd_Z": sd[2::3],
+        }
+    ).set_index("point")  # fmt: skip
+
+
+def _ecef_to_utm(epsg: int) -> Callable[[np.ndarray], np.ndarray]:
+    """Function ECEF -> (E, N, ellipsoidal height) of the UTM zone `epsg`."""
+    to_utm = Transformer.from_crs("EPSG:4978", f"EPSG:{epsg}", always_xy=True)
+    return lambda xyz: np.array(to_utm.transform(*xyz))
+
+
+def _propagate(
+    f: Callable[[np.ndarray], np.ndarray],
+    X: np.ndarray,
+    C: np.ndarray,
+    step: float = 1.0,
+) -> np.ndarray:
+    """Covariance of f(X) as J C J^T, with the Jacobian J by central differences [step m]."""
+    J = np.column_stack([(f(X + step * e) - f(X - step * e)) / (2 * step) for e in np.eye(3)])
+    return J @ C @ J.T
+
+
+def utm_table(adj: Adjustment, utm_epsg: int = 32632) -> pd.DataFrame:
+    """UTM coordinates (ellipsoidal height) with propagated standard deviations.
+
+    The covariance is propagated as C_utm = J C J^T, with J = d(E, N, h) / d(X, Y, Z)
+    computed by central differences. Fixed points are listed with zero standard deviation.
+    The input ECEF coordinates are treated as WGS84, which equals ETRF2000 / RDN2008 within
+    the accuracy of GNSS; for those frames pass their UTM code (e.g. 7791 for RDN2008 UTM 32N).
+
+    Args:
+        adj: Result of `adjust_network`.
+        utm_epsg: EPSG code of the UTM zone (32632 = WGS84 UTM 32N, 7791 = RDN2008 UTM 32N).
+
+    Returns:
+        DataFrame with point, E, N, h_ell, sd_E, sd_N, sd_h [m]; unknown points first.
+    """
+    ecef_to_utm = _ecef_to_utm(utm_epsg)
+    rows = []
+    for j, point in enumerate(adj.unknowns):
+        X = adj.X_hat[3 * j : 3 * j + 3]  # adjusted ECEF coordinates
+        C = adj.Cxx[3 * j : 3 * j + 3, 3 * j : 3 * j + 3]  # their 3x3 covariance
+        sd = np.sqrt(np.diag(_propagate(ecef_to_utm, X, C)))
+        rows.append([point, *ecef_to_utm(X), *sd])
+    for point, X in adj.fixed.items():
+        rows.append([point, *ecef_to_utm(X), 0.0, 0.0, 0.0])
+    return pd.DataFrame(rows, columns=["point", "E", "N", "h_ell", "sd_E", "sd_N", "sd_h"])
+
+
+def coordinate_table(adj: Adjustment, utm_epsg: int = 32632) -> pd.DataFrame:
+    """All adjusted points (fixed ones last): ECEF, geographic and UTM, with standard deviations.
+
+    Geographic coordinates are on GRS80 (ellipsoidal height), UTM coordinates in `utm_epsg`.
+
+    Args:
+        adj: Result of `adjust_network`.
+        utm_epsg: EPSG code of the UTM zone (32632 = WGS84 UTM 32N, 7791 = RDN2008 UTM 32N).
+
+    Returns:
+        DataFrame indexed by point, with the ECEF, geographic and UTM columns.
+    """
+    utm = utm_table(adj, utm_epsg).set_index("point")
+    ecef = ecef_table(adj)
+    fixed = pd.DataFrame(
+        [[*X, 0.0, 0.0, 0.0] for X in adj.fixed.values()],
+        index=pd.Index(list(adj.fixed), name="point"),
+        columns=ecef.columns,
+    )
+    table = pd.concat([ecef, fixed]).join(utm.drop(columns="h_ell"))
+    lat, lon, h = ecef_to_llh(*table[["X", "Y", "Z"]].to_numpy().T)
+    table.insert(6, "lat", lat)
+    table.insert(7, "lon", lon)
+    table.insert(8, "h_ell", h)
+    table.insert(0, "fixed", table.index.isin(list(adj.fixed)))
+    return table.reset_index()

gnsskit/static/solve.py

@@ -0,0 +1,54 @@
+"""Static solution of a rover over a time window (one rnx2rtkp run, last filter epoch)."""
+
+from __future__ import annotations
+
+import tempfile
+from collections.abc import Sequence
+from pathlib import Path
+
+import pandas as pd
+
+from ..rtklib.config import RtkConfig
+from ..rtklib.pos import read_pos
+from ..rtklib.runner import run_rnx2rtkp
+
+
+def solve_static(
+    rover: Path | str,
+    base: Path | str,
+    nav: Sequence[Path | str],
+    config: RtkConfig,
+    start: pd.Timestamp,
+    end: pd.Timestamp,
+    exe: str = "rnx2rtkp",
+    tint: float | None = None,
+) -> pd.Series | None:
+    """Static solution over [start, end], run in a temporary directory.
+
+    Args:
+        rover: Rover RINEX observation file.
+        base: Base RINEX observation file.
+        nav: Navigation, precise orbit and clock files (see `run_rnx2rtkp`).
+        config: RTKLIB processing options.
+        start: Processing start time, GPST.
+        end: Processing end time, GPST.
+        exe: rnx2rtkp executable name or path.
+        tint: Processing interval [s]. None for every epoch.
+
+    Returns:
+        The last (cumulative) epoch of the forward filter as a row of the `read_pos` table,
+        or None if there is no solution.
+
+    Raises:
+        FileNotFoundError: If the executable is not found.
+        RuntimeError: If rnx2rtkp exits with a non-zero code.
+    """
+    with tempfile.TemporaryDirectory() as tmp:
+        out = run_rnx2rtkp(
+            rover, base, nav, config, Path(tmp) / "out.pos",
+            start=start, end=end, tint=tint, exe=exe,
+        )  # fmt: skip
+        if not out.exists() or out.stat().st_size == 0:
+            return None
+        pos = read_pos(out)
+    return pos.iloc[-1] if len(pos) else None

gnsskit-0.4.0.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: gnsskit
+Version: 0.4.0
+Summary: RTKLIB-based GNSS post-processing toolkit: RINEX tools, RTKLIB wrappers, static baselines and network adjustment, kinematic trajectories
+Keywords: gnss,gps,rtklib,ppk,surveying,least-squares
+Author: Francesco Ioli
+Author-email: Francesco Ioli <francesco.ioli@polimi.it>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Dist: numpy
+Requires-Dist: pandas>=2
+Requires-Dist: scipy ; extra == 'network'
+Requires-Dist: pyproj ; extra == 'network'
+Requires-Dist: matplotlib ; extra == 'plot'
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/franioli/gnsskit
+Project-URL: Issues, https://github.com/franioli/gnsskit/issues
+Provides-Extra: network
+Provides-Extra: plot
+Description-Content-Type: text/markdown
+
+# gnsskit
+
+Shared tools for post-processing GNSS data with [RTKLIB](https://www.rtklib.com/) `rnx2rtkp`, used by
+[djippk](https://github.com/franioli/djippk) (drone PPK) and [stopgo](https://github.com/franioli/stopgo)
+(stop-and-go surveys).
+
+- **RTKLIB wrappers** (`gnsskit.rtklib`): `RtkConfig`, a typed, immutable set of `rnx2rtkp` options
+  (`from_file`, `updated`, `with_options`, `with_base_llh`, `write`); `run_rnx2rtkp` and `find_rnx2rtkp`;
+  `read_pos` (llh, xyz and enu `.pos` files).
+- **RINEX** (`gnsskit.rinex`): `rinex_span`, `header_llh`, `trim_rinex`; inspection with `obs_summary`
+  (span, sampling, gaps, satellites), `read_visibility` and `plot_visibility` (RTKPLOT-style satellite
+  visibility, needs the `plot` extra).
+- **Static** (`gnsskit.static`): `solve_static` (one solution over a time window), `process_baseline`
+  (static baselines with covariance), baseline IO and `loop_closures` (misclosure of every triangle of baselines); least-squares adjustment of a redundant baseline
+  network in `gnsskit.static.network` (needs the `network` extra).
+- **Kinematic** (`gnsskit.kinematic`): trajectory interpolation and averaging.
+- **Reference systems** (`gnsskit.refsys`): GPST/UTC, ellipsoids, ECEF/geodetic conversions and
+  `ENUFrame`, a local east-north-up frame at a point (points, vectors and covariances, both ways).
+
+## Install
+
+```sh
+pip install gnsskit                  # library
+pip install "gnsskit[network]"       # + network adjustment (scipy, pyproj)
+pip install "gnsskit[network,plot]"  # + satellite visibility plots (matplotlib)
+pip install git+https://github.com/franioli/gnsskit   # development version
+```
+
+`rnx2rtkp` is not installed by pip. Build the [demo5 fork](https://github.com/rtklibexplorer/RTKLIB) and put it on
+your `PATH`; if it is missing, `run_rnx2rtkp` raises an error with instructions. Developed with `rnx2rtkp ver.EX 2.5.1`.
+
+## Example
+
+```python
+from gnsskit import RtkConfig, read_pos, run_rnx2rtkp
+
+config = RtkConfig(posmode="static", navsys="GEC", solformat="llh").with_base_llh(46.2, 9.8, 2300.0)
+pos_file = run_rnx2rtkp(rover_obs, base_obs, [nav], config, "out.pos")
+pos = read_pos(pos_file)
+```
+
+See [example/](https://github.com/franioli/gnsskit/tree/main/example) for complete static, kinematic and network adjustment examples.

gnsskit-0.4.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+gnsskit/__init__.py,sha256=Vc0w5O7xgj98-Qy20FGIfKqso_5g4-v42eUZk2b3A_E,1360
+gnsskit/kinematic/__init__.py,sha256=acQv70N3oaqU_yc2W1KI10eO1lAcrgNW5zDcQBHZMr4,177
+gnsskit/kinematic/trajectory.py,sha256=UdVASx4N7jBRrDxM0c_WeeoRgvKvDcqHnGLxyDISwd8,2949
+gnsskit/ppp/__init__.py,sha256=dwsBzFMH3ZFIt5H7FmtgjnUto69LwK4Rak5WgWdyA9A,758
+gnsskit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gnsskit/refsys.py,sha256=AxtzYyf800vDS9IihBMjY2Hm8RFhK0T9jVZlsG0a1V4,10791
+gnsskit/rinex.py,sha256=UPAU4JLaAeVBF73jMKE_r4ia5thoT5J3VirP8oexafU,17184
+gnsskit/rtklib/__init__.py,sha256=36tnultivDVoy8lYGQNDGN3wjJ3TXMZr5FkTucmypsE,460
+gnsskit/rtklib/config.py,sha256=NyCLeLjaMw2hqGLXzsORQr-6gyiy9-eSObu7GthtyAc,13699
+gnsskit/rtklib/pos.py,sha256=EfGQF7-3DOPTNPAhib5tivPJV2_bBylaywjV2mjDDPA,5888
+gnsskit/rtklib/runner.py,sha256=EgWaUFY9GkaNfGldWDKDULSg1qwcv-2INzn5PV8p6Mc,5083
+gnsskit/static/__init__.py,sha256=ZR0KDTSTb5PuEjKSaxM1Xr_GLbb_kM5uAS1SI7QVzo4,758
+gnsskit/static/baseline.py,sha256=QfKljWZThrIhj23yUr-4ricUo2yAPdAksXxW6xd8cGg,11632
+gnsskit/static/closure.py,sha256=xFFSLAfaYw63Js8HfoeesuSbfHaTyqKGLgJ_z_qhLq8,3551
+gnsskit/static/network.py,sha256=XeAi7y1X6yK-8nDsl1ZlXcRaq2brxyYCn2sqPs6M2XQ,17997
+gnsskit/static/solve.py,sha256=11vsP3LRz028rsYT5obonHcRkJ1ZHDrf7pJh6joI_C8,1728
+gnsskit-0.4.0.dist-info/licenses/LICENSE,sha256=dLFf8Hru3SXGRjRJtNJ6yGCpMYutI00NKvyX8Q5oyTo,1076
+gnsskit-0.4.0.dist-info/WHEEL,sha256=si2p8vW03RnhyBnhWl4tj-ObJa78SpE-c9HsEtblGR0,80
+gnsskit-0.4.0.dist-info/METADATA,sha256=opONMGjSqWXYsTYMOr-uWoK6DH73ryj-g4Za2WaVlJE,3512
+gnsskit-0.4.0.dist-info/RECORD,,

gnsskit-0.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.5
+Root-Is-Purelib: true
+Tag: py3-none-any

gnsskit-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 Francesco Ioli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.