sarkit-convert 0.1.0__tar.gz

sarkit_convert-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Valkyrie Systems Corporation
+
+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.
+

sarkit_convert-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.1
+Name: sarkit-convert
+Version: 0.1.0
+Summary: Python library for converting SAR data to standard formats.
+Author-Email: Valkyrie Systems Corporation <info@govsco.com>
+License: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: lxml>=5.1.0
+Requires-Dist: numpy>=1.26.3
+Requires-Dist: sarkit[verification]>=0.6.0
+Provides-Extra: iceye
+Requires-Dist: h5py>=3.12.1; extra == "iceye"
+Requires-Dist: python-dateutil>=2.9.0; extra == "iceye"
+Provides-Extra: cosmo
+Requires-Dist: h5py>=3.12.1; extra == "cosmo"
+Requires-Dist: python-dateutil>=2.9.0; extra == "cosmo"
+Requires-Dist: scipy>=1.15.1; extra == "cosmo"
+Requires-Dist: shapely>=2.0.2; extra == "cosmo"
+Provides-Extra: tsx
+Requires-Dist: lxml>=5.1.0; extra == "tsx"
+Requires-Dist: python-dateutil>=2.9.0; extra == "tsx"
+Requires-Dist: sarkit[verification]>=0.5.0; extra == "tsx"
+Requires-Dist: scipy>=1.15.1; extra == "tsx"
+Provides-Extra: sentinel
+Requires-Dist: python-dateutil>=2.9.0; extra == "sentinel"
+Requires-Dist: scipy>=1.15.1; extra == "sentinel"
+Requires-Dist: tifffile>=2025.5.10; extra == "sentinel"
+Provides-Extra: all
+Requires-Dist: sarkit-convert[iceye]; extra == "all"
+Requires-Dist: sarkit-convert[cosmo]; extra == "all"
+Requires-Dist: sarkit-convert[tsx]; extra == "all"
+Requires-Dist: sarkit-convert[sentinel]; extra == "all"
+Provides-Extra: dev-lint
+Requires-Dist: ruff>=0.3.0; extra == "dev-lint"
+Requires-Dist: mypy>=1.8.0; extra == "dev-lint"
+Requires-Dist: types-python-dateutil>=2.9.0; extra == "dev-lint"
+Provides-Extra: dev-test
+Requires-Dist: pytest>=7.4.4; extra == "dev-test"
+Provides-Extra: dev
+Requires-Dist: sarkit-convert[dev-lint,dev-test]; extra == "dev"
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/ValkyrieSystems/sarkit/main/docs/source/_static/sarkit_logo.png" width=200>
+
+</div>
+
+**sarkit-convert** is a Python library for converting SAR data to standard formats.
+
+## License
+This repository is licensed under the [MIT license](./LICENSE).
+
+A few tips for getting started using [PDM](https://pdm-project.org/en/latest/) are below:
+
+
+```shell
+$ pdm install -G:all  # install SARkit-convert with optional & dev dependencies
+$ pdm run nox  # run lint and tests
+```

sarkit_convert-0.1.0/README.md

@@ -0,0 +1,18 @@
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/ValkyrieSystems/sarkit/main/docs/source/_static/sarkit_logo.png" width=200>
+
+</div>
+
+**sarkit-convert** is a Python library for converting SAR data to standard formats.
+
+## License
+This repository is licensed under the [MIT license](./LICENSE).
+
+A few tips for getting started using [PDM](https://pdm-project.org/en/latest/) are below:
+
+
+```shell
+$ pdm install -G:all  # install SARkit-convert with optional & dev dependencies
+$ pdm run nox  # run lint and tests
+```

sarkit_convert-0.1.0/pyproject.toml

@@ -0,0 +1,117 @@
+[project]
+name = "sarkit-convert"
+description = "Python library for converting SAR data to standard formats."
+authors = [
+    { name = "Valkyrie Systems Corporation", email = "info@govsco.com" },
+]
+requires-python = ">=3.11"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Scientific/Engineering",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dynamic = []
+dependencies = [
+    "lxml>=5.1.0",
+    "numpy>=1.26.3",
+    "sarkit[verification]>=0.6.0",
+]
+version = "0.1.0"
+
+[project.license]
+text = "MIT"
+
+[project.optional-dependencies]
+iceye = [
+    "h5py>=3.12.1",
+    "python-dateutil>=2.9.0",
+]
+cosmo = [
+    "h5py>=3.12.1",
+    "python-dateutil>=2.9.0",
+    "scipy>=1.15.1",
+    "shapely>=2.0.2",
+]
+tsx = [
+    "lxml>=5.1.0",
+    "python-dateutil>=2.9.0",
+    "sarkit[verification]>=0.5.0",
+    "scipy>=1.15.1",
+]
+sentinel = [
+    "python-dateutil>=2.9.0",
+    "scipy>=1.15.1",
+    "tifffile>=2025.5.10",
+]
+all = [
+    "sarkit-convert[iceye]",
+    "sarkit-convert[cosmo]",
+    "sarkit-convert[tsx]",
+    "sarkit-convert[sentinel]",
+]
+dev-lint = [
+    "ruff>=0.3.0",
+    "mypy>=1.8.0",
+    "types-python-dateutil>=2.9.0",
+]
+dev-test = [
+    "pytest>=7.4.4",
+]
+dev = [
+    "sarkit-convert[dev-test,dev-lint]",
+]
+
+[dependency-groups]
+test = [
+    "nox>=2024.3.2",
+]
+doc = [
+    "sphinx>=7.2.6",
+    "numpydoc>=1.7.0",
+    "sphinx-rtd-theme>=2.0.0",
+    "sphinxcontrib-autoprogram>=0.1.9",
+]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.version]
+source = "scm"
+write_to = "sarkit_convert/_version.py"
+write_template = "__version__ = '{}'"
+
+[tool.ruff.lint]
+select = [
+    "E4",
+    "E7",
+    "E9",
+    "F",
+    "I",
+    "N",
+    "NPY",
+    "ISC",
+    "RUF022",
+]
+preview = true
+
+[[tool.mypy.overrides]]
+module = [
+    "h5py.*",
+    "lxml.*",
+    "scipy.*",
+    "shapely.*",
+]
+ignore_missing_imports = true

sarkit_convert-0.1.0/sarkit_convert/__init__.py

@@ -0,0 +1,17 @@
+"""
+======================
+SARkit-convert (:mod:`sarkit-convert`)
+======================
+
+The main namespace is almost empty by design.
+
+.. list-table::
+
+   * - ``__version__``
+     - SARkit-convert version string
+
+"""
+
+from sarkit_convert._version import __version__
+
+__all__ = ["__version__"]

sarkit_convert-0.1.0/sarkit_convert/_utils.py

@@ -0,0 +1,253 @@
+"""
+=====================================
+Utility functions for SICD converters
+=====================================
+
+Common utility functions for use in SICD converters
+
+"""
+
+import itertools
+
+import numpy as np
+import numpy.polynomial.polynomial as npp
+import sarkit.wgs84
+
+RNIIRS_FIT_PARAMETERS = np.array([3.4761, 0.4357], dtype="float64")
+
+
+def fit_state_vectors(
+    fit_time_range, times, positions, velocities=None, accelerations=None, order=5
+):
+    times = np.asarray(times)
+    positions = np.asarray(positions)
+    knots_per_state = 1
+    if velocities is not None:
+        velocities = np.asarray(velocities)
+        knots_per_state += 1
+    if accelerations is not None:
+        accelerations = np.asarray(accelerations)
+        knots_per_state += 1
+
+    num_coefs = order + 1
+    states_needed = int(np.ceil(num_coefs / knots_per_state))
+    if states_needed > times.size:
+        raise ValueError("Not enough state vectors")
+    start_state = max(np.sum(times < fit_time_range[0]) - 1, 0)
+    end_state = min(np.sum(times < fit_time_range[1]) + 1, times.size)
+    while end_state - start_state < states_needed:
+        start_state = max(start_state - 1, 0)
+        end_state = min(end_state + 1, times.size)
+
+    rnc = np.arange(num_coefs)
+    used_states = slice(start_state, end_state)
+    used_times = times[used_states][:, np.newaxis]
+    independent_stack = [used_times**rnc]
+    dependent_stack = [positions[used_states, :]]
+    if velocities is not None:
+        independent_stack.append(rnc * used_times ** (rnc - 1).clip(0))
+        dependent_stack.append(velocities[used_states, :])
+    if accelerations is not None:
+        independent_stack.append(rnc * (rnc - 1) * used_times ** (rnc - 2).clip(0))
+        dependent_stack.append(accelerations[used_states, :])
+
+    dependent = np.stack(dependent_stack, axis=-2)
+    independent = np.stack(independent_stack, axis=-2)
+    return np.linalg.lstsq(
+        independent.reshape(-1, independent.shape[-1]),
+        dependent.reshape(-1, dependent.shape[-1]),
+        rcond=-1,
+    )[0]
+
+
+def polyfit2d(x, y, z, order1, order2):
+    """Fits 2d polynomials to data."""
+    if x.ndim != 1 or y.ndim != 1:
+        raise ValueError("Expected x and y to be one dimensional")
+    if not 0 < z.ndim <= 2:
+        raise ValueError("Expected z to be one or two dimensional")
+    if not x.shape[0] == y.shape[0] == z.shape[0]:
+        raise ValueError("Expected x, y, z to have same leading dimension size")
+    vander = npp.polyvander2d(x, y, (order1, order2))
+    scales = np.sqrt(np.square(vander).sum(0))
+    coefs_flat = (np.linalg.lstsq(vander / scales, z, rcond=-1)[0].T / scales).T
+    return coefs_flat.reshape(order1 + 1, order2 + 1)
+
+
+def polyfit2d_tol(x, y, z, max_order_x, max_order_y, tol, strict_tol=False):
+    """Fits 2D polys of minimum order to bring the maximum residual under tol.
+
+    Args
+    ----
+    x: array-like
+        First independent variable values. One dimensional.
+    y: array-like
+        Second independent variable values. One dimensional.
+    z: array-like
+        Dependent variable values. Leading dimension must have same size as `x` and `y` .
+    max_order_x: int
+        The maximum order in `x` to consider
+    max_order_y: int
+        The maximum order in `y` to consider
+    tol: float
+        The maximum residual requested.
+    strict_tol: bool
+        ``True`` if an exception should be raised if `tol` is not met with allowed orders.
+
+        If ``False``, return best fitting polynomial of allowed order.
+
+    Returns
+    -------
+    poly
+        2d polynomials of common orders no greater than `(max_order_x, max_order_y)` .
+
+    Raises
+    ------
+    `ValueError`
+        If `strict_tol` and tolerance is not reached.
+
+    """
+    orders = sorted(
+        list(itertools.product(range(max_order_x + 1), range(max_order_y + 1))),
+        key=lambda x: (x[0] + 1) * (x[1] + 1),
+    )
+    best = None
+    for order_x, order_y in orders:
+        poly = polyfit2d(x, y, z, order_x, order_y)
+        resid = np.abs(z - np.moveaxis(npp.polyval2d(x, y, poly), 0, -1)).max()
+        if resid <= tol:
+            return poly
+        if best is None or resid < best[1]:
+            best = (poly, resid)
+    if strict_tol:
+        raise ValueError("Max order exceeded before tolerance was reached")
+    return best[0]
+
+
+def broadening_from_amp(amp_vals, threshold_db=None):
+    """Compute the broadening factor from amplitudes
+
+    Parameters
+    ----------
+    amp_vals: array-like
+        window amplitudes
+    threshold_db: float, optional
+        threshold to use to compute broadening (Default: 10*log10(0.5))
+
+    Returns
+    -------
+    float
+
+    """
+    if threshold_db is None:
+        threshold = np.sqrt(0.5)
+    else:
+        threshold = 10 ** (threshold_db / 20)
+    amp_vals = np.asarray(amp_vals)
+    fft_size = 2 ** int(np.ceil(np.log2(amp_vals.size * 10000)))
+    impulse_response = np.abs(np.fft.fft(amp_vals, fft_size))
+    impulse_response /= impulse_response.max()
+    width = (impulse_response[: fft_size // 2] < threshold).argmax() + (
+        impulse_response[-1 : fft_size // 2 : -1] > threshold
+    ).argmin()
+
+    return width / fft_size * amp_vals.size
+
+
+def _get_sigma0_noise(xml_helper):
+    """Calculate the absolute noise estimate, in sigma0 power units."""
+
+    if xml_helper.element_tree.find("./{*}Radiometric/{*}SigmaZeroSFPoly") is None:
+        raise ValueError(
+            "Radiometric.SigmaZeroSFPoly is not populated, so no sigma0 noise estimate can be derived."
+        )
+    if (
+        xml_helper.load("./{*}Radiometric/{*}NoiseLevel/{*}NoiseLevelType")
+        != "ABSOLUTE"
+    ):
+        raise ValueError(
+            "Radiometric.NoiseLevel.NoiseLevelType is not `ABSOLUTE` so no noise estimate can be derived."
+        )
+
+    noisepoly = xml_helper.load("./{*}Radiometric/{*}NoiseLevel/{*}NoisePoly")
+    scp_noise_db = noisepoly[0, 0]
+    scp_noise = 10 ** (scp_noise_db / 10)
+
+    # convert to SigmaZero value
+    sigma_zero_sf = xml_helper.load("./{*}Radiometric/{*}SigmaZeroSFPoly")
+    scp_noise *= sigma_zero_sf[0, 0]
+
+    return scp_noise
+
+
+def _get_default_signal_estimate(xml_helper):
+    """Gets default signal for use in the RNIIRS calculation.
+
+    This will be 1.0 for copolar (or unknown) collections, and 0.25 for cross-pole collections."""
+
+    pol = xml_helper.load("./{*}ImageFormation/{*}TxRcvPolarizationProc")
+    if pol is None or ":" not in pol:
+        return 1.0
+
+    pols = pol.split(":")
+
+    return 1.0 if pols[0] == pols[1] else 0.25
+
+
+def _estimate_rniirs(information_density):
+    """Calculate an RNIIRS estimate from the information density or Shannon-Hartley channel capacity.
+
+    This mapping has been empirically determined by fitting Shannon-Hartley channel
+    capacity to RNIIRS for some sample images.
+
+    To maintain positivity of the estimated rniirs, this transitions to a linear
+    model.
+
+    """
+    a = RNIIRS_FIT_PARAMETERS
+    iim_transition = np.exp(1 - np.log(2) * a[0] / a[1])
+    slope = a[1] / (iim_transition * np.log(2))
+
+    if not isinstance(information_density, np.ndarray):
+        information_density = np.array(information_density, dtype="float64")
+    orig_ndim = information_density.ndim
+    if orig_ndim == 0:
+        information_density = np.reshape(information_density, (1,))
+
+    out = np.empty(information_density.shape, dtype="float64")
+    mask = information_density > iim_transition
+    mask_other = ~mask
+    if np.any(mask):
+        out[mask] = a[0] + a[1] * np.log2(information_density[mask])
+    if np.any(mask_other):
+        out[mask_other] = slope * information_density[mask_other]
+
+    if orig_ndim == 0:
+        return float(out[0])
+    return out
+
+
+def get_rniirs_estimate(xml_helper):
+    """This calculates the value(s) for RNIIRS and information density for SICD, according to the RGIQE."""
+    scp_noise = _get_sigma0_noise(xml_helper)
+    signal = _get_default_signal_estimate(xml_helper)
+
+    u_row = xml_helper.load("./{*}Grid/{*}Row/{*}UVectECF")
+    u_col = xml_helper.load("./{*}Grid/{*}Col/{*}UVectECF")
+    ipn = np.cross(u_row, u_col)
+    u_ipn = ipn / np.linalg.norm(ipn)
+
+    scp_llh = xml_helper.load("./{*}GeoData/{*}SCP/{*}LLH")
+    u_gpn = sarkit.wgs84.up(scp_llh)
+
+    bw_sf = np.dot(u_gpn, u_ipn)
+    bw_area = abs(
+        xml_helper.load("./{*}Grid/{*}Row/{*}ImpRespBW")
+        * xml_helper.load("./{*}Grid/{*}Col/{*}ImpRespBW")
+        * bw_sf
+    )
+
+    inf_density = float(bw_area * np.log2(1 + signal / scp_noise))
+    rniirs = float(_estimate_rniirs(inf_density))
+
+    return inf_density, rniirs

sarkit_convert-0.1.0/sarkit_convert/_version.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'