arepytools 1.7.6__tar.gz

arepytools-1.7.6/.gitignore

@@ -0,0 +1,35 @@
+# Byte-compiled / optimized
+__pycache__
+*.py[co]
+
+# Distribution / packaging
+build/
+_build/
+dist/
+*.egg-info/
+.ipynb_checkpoints/
+arepytools/meta.yaml
+conda_build_dir
+
+# Pyenv
+.python-version
+
+# VS Code project settings
+.vscode
+
+# PyCharm project settings
+.idea
+
+# Spyder project settings
+.spyproject
+
+# Environments
+venv*
+.venv
+
+# Other
+*.bak
+.coverage
+htmlcov
+xsd/*xsd
+.pdm*

arepytools-1.7.6/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) Aresys S.r.l. <info@aresys.it>
+
+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.

arepytools-1.7.6/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: arepytools
+Version: 1.7.6
+Summary: ArePyTools is the Aresys Python toolset for SAR data processing.
+Author-email: "Aresys S.R.L." <info@aresys.it>
+License: MIT License
+        
+        Copyright (C) Aresys S.r.l. <info@aresys.it>
+        
+        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.
+License-File: LICENSE.txt
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: lxml
+Requires-Dist: numpy>=1.20
+Requires-Dist: python-dateutil
+Requires-Dist: scipy
+Requires-Dist: xsdata
+Provides-Extra: bench
+Requires-Dist: arepyextras-benchmark; extra == 'bench'
+Provides-Extra: dev
+Requires-Dist: nox; extra == 'dev'
+Requires-Dist: pylint; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: doc
+Requires-Dist: ipython; extra == 'doc'
+Requires-Dist: nbsphinx; extra == 'doc'
+Requires-Dist: pydata-sphinx-theme; extra == 'doc'
+Requires-Dist: sphinx-copybutton; extra == 'doc'
+Requires-Dist: sphinx-design; extra == 'doc'
+Requires-Dist: sphinx<8.2; extra == 'doc'
+Provides-Extra: test
+Requires-Dist: coverage; extra == 'test'
+Requires-Dist: unittest-xml-reporting; extra == 'test'
+Description-Content-Type: text/markdown
+
+# ArePyTools
+

arepytools-1.7.6/README.md

@@ -0,0 +1,2 @@
+# ArePyTools
+

arepytools-1.7.6/arepytools/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""
+ArePyTools: the Python toolkit for SAR data processing
+"""
+
+__version__ = "1.7.6"

arepytools-1.7.6/arepytools/constants.py

@@ -0,0 +1,109 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+
+"""
+**Deprecated** Constants module
+-------------------------------
+
+.. deprecated:: v1.7.0
+    Importing constants is deprecated.
+    Use scipy.constants.speed_of_light for LIGHT_SPEED.
+
+Examples
+--------
+>>> import arepytools.constants as cst
+>>> print(cst.LIGHT_SPEED)
+299792458.0
+"""
+import warnings
+
+import scipy
+
+warnings.warn(
+    "arepytools.constants module is deprecated. Instead of importing LIGHT_SPEED use 'from scipy.constants import speed_of_light'",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+SECONDS_IN_A_DAY = 86164.09054
+"""
+Number of seconds in a day
+"""
+
+LIGHT_SPEED = scipy.constants.speed_of_light
+"""
+Speed of light in vacuum (m/s).
+"""
+
+# Units of measure
+SECOND_STR = "s"
+"""
+Second symbol.
+"""
+
+HERTZ_STR = "Hz"
+"""
+Hertz symbol.
+"""
+
+JOULE_STR = "j"
+"""
+Joule symbol.
+"""
+
+DEGREE_STR = "deg"
+"""
+Degree symbol.
+"""
+
+RAD_STR = "rad"
+"""
+Radian symbol.
+"""
+
+UTC_STR = "Utc"
+"""
+Coordinated Universal Time abbreviation.
+"""
+
+METER_STR = "m"
+"""
+Meter symbol.
+"""
+
+# Metric prefixes
+KILO = 1e3
+"""
+Number of units in one kilounit (kilounits-to-units conversion factor).
+"""
+
+MEGA = KILO**2
+"""
+Number of units in one megaunit (megaunits-to-units conversion factor).
+"""
+
+GIGA = KILO**3
+"""
+Number of units in one gigaunit (gigaunits-to-units conversion factor).
+"""
+
+MILLI = KILO**-1
+"""
+Number of units in one milliunit (milliunits-to-units conversion factor).
+"""
+
+MICRO = KILO**-2
+"""
+Number of units in one microunit (microunits-to-units conversion factor).
+"""
+
+NANO = KILO**-3
+"""
+Number of units in one nanounit (nanounits-to-units conversion factor).
+"""
+
+PICO = KILO**-4
+"""
+Number of units in one picounit (picounits-to-units conversion factor).
+"""

arepytools-1.7.6/arepytools/geometry/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""
+Geometry management package
+"""

arepytools-1.7.6/arepytools/geometry/_geodetic.py

@@ -0,0 +1,107 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""
+Geodetic module
+---------------
+"""
+
+import numpy as np
+import numpy.typing as npt
+
+from arepytools.geometry.conversions import llh2xyz, xyz2llh
+from arepytools.geometry.ellipsoid import WGS84
+
+_semi_axis_ratio_sqr = WGS84.semi_axes_ratio_min_max**2
+_major_semi_axis_sqr = WGS84.semi_major_axis**2
+_minor_semi_axis_sqr = WGS84.semi_minor_axis**2
+
+
+def _ze(x: float, y: float) -> float:
+    eps = 1.0e-21
+
+    return np.sqrt(_minor_semi_axis_sqr - _semi_axis_ratio_sqr * (x**2 + y**2)) + eps
+
+
+def _ze_x(x: float, y: float) -> float:
+    return -WGS84.semi_axes_ratio_min_max * x / _ze(x, y)
+
+
+def _ze_xy(x: float, y: float) -> float:
+    # pylint: disable-next=arguments-out-of-order
+    return (_semi_axis_ratio_sqr * x) / _ze(x, y) ** 2 * _ze_x(y, x)
+
+
+def _ze_xx(x: float, y: float) -> float:
+    return -_semi_axis_ratio_sqr / _ze(x, y) + (_semi_axis_ratio_sqr * x) / _ze(x, y) ** 2 * _ze_x(x, y)
+
+
+def _compute_geodetic_jacobian(point: np.ndarray, sensor_position: np.ndarray) -> np.ndarray:
+    jac = np.empty(shape=(3, 3), dtype=float)
+
+    zed_diff = point[2] - sensor_position[2]
+
+    jac[0][0] = 2.0 * point[0] / _major_semi_axis_sqr
+    jac[0][1] = 2.0 * point[1] / _major_semi_axis_sqr
+    jac[0][2] = 2.0 * point[2] / _minor_semi_axis_sqr
+    jac[1][0] = 1.0 + zed_diff * _ze_xx(point[0], point[1])
+    jac[1][1] = zed_diff * _ze_xy(point[0], point[1])
+    jac[1][2] = _ze_x(point[0], point[1])
+    jac[2][0] = jac[1][1]
+    jac[2][1] = 1.0 + zed_diff * _ze_xx(point[1], point[0])
+    jac[2][2] = _ze_x(point[1], point[0])
+
+    return jac
+
+
+def _compute_geodetic_rhs(point: npt.NDArray[np.floating], sensor_position: npt.NDArray[np.floating]) -> np.ndarray:
+    rhs = np.empty(shape=(3,), dtype=float)
+    los = point - sensor_position
+    rhs[0] = (point[0] ** 2 + point[1] ** 2) / _major_semi_axis_sqr + point[2] ** 2 / _minor_semi_axis_sqr - 1
+    rhs[1] = los[0] + los[2] * _ze_x(point[0], point[1])
+    rhs[2] = los[1] + los[2] * _ze_x(point[1], point[0])
+    return rhs
+
+
+def compute_geodetic_point(sensor_positions: npt.ArrayLike) -> np.ndarray:
+    """Compute the geodetic point that corresponds to a sensor position
+
+    :param sensor_position: sensor position array like with shape (3,) or (N, 3)
+
+    :return: geodetic point as a (3,) or (N, 3) numpy array
+    """
+    sensor_positions = np.asarray(sensor_positions)
+
+    if sensor_positions.ndim > 2 or sensor_positions.shape[-1] != 3:
+        raise ValueError(f"sensor_positions has invalid shape: {sensor_positions.shape}, it should be (3,) or (N, 3)")
+
+    sensor_positions = sensor_positions.copy()
+    change_sign = sensor_positions[..., 2] < 0
+    sensor_positions[change_sign, 2] *= -1
+
+    geodetic_points = xyz2llh(sensor_positions.T)
+    geodetic_points[2, ...] = 0
+    geodetic_points = llh2xyz(geodetic_points).T.reshape(sensor_positions.shape)
+
+    for sensor_position, point in zip(
+        sensor_positions.reshape((-1, 3)),
+        geodetic_points.reshape((-1, 3)),
+    ):
+        increment_norm_threshold = 1e-9
+        max_num_iterations = 10
+        for _ in range(max_num_iterations):
+            jacobian = _compute_geodetic_jacobian(point[:], sensor_position)
+            rhs = _compute_geodetic_rhs(point[:], sensor_position)
+
+            increment = -np.linalg.solve(jacobian, rhs)
+
+            increment_norm = np.linalg.norm(increment)
+
+            point[:] += increment
+
+            if increment_norm < increment_norm_threshold:
+                break
+
+    geodetic_points[change_sign, 2] *= -1
+
+    return geodetic_points

arepytools-1.7.6/arepytools/geometry/_interpolator.py

@@ -0,0 +1,210 @@
+# SPDX-FileCopyrightText: Aresys S.r.l. <info@aresys.it>
+# SPDX-License-Identifier: MIT
+
+"""
+Geometry interpolator module
+----------------------------
+"""
+
+import numpy as np
+
+
+def check_eval_function_input(fun):
+    """
+    Interpolator eval function input checker
+    """
+
+    def decorated_fun(self, *args_f, **kwargs_f):
+        if isinstance(args_f[0], (list, np.ndarray)):
+            interpolation_axis = np.asarray(args_f[0])
+        else:
+            interpolation_axis = np.full((1,), args_f[0])
+        return fun(self, interpolation_axis, *args_f[1:], **kwargs_f)
+
+    return decorated_fun
+
+
+class GeometryInterpolator:
+    """
+    Internal class for handling interpolation in GeneralSarOrbit and in GeneralSarAttitude
+    It interpolates vector-valued functions defined on a given axis
+    """
+
+    _POLYNOMIAL_ORDER = 4
+    _DATA_POINTS_PER_POLY = _POLYNOMIAL_ORDER + 1
+    _POLY_CENTER_REL_INTERVAL_INDEX = _DATA_POINTS_PER_POLY // 2
+
+    @classmethod
+    def get_min_num_of_data_points(cls):
+        """Return the minimum number of data points needed by the interpolator
+
+        :return: minimum number of data points"""
+        return cls._DATA_POINTS_PER_POLY
+
+    @classmethod
+    def get_polynomial_order(cls):
+        """Return the order of the interpolation polynomial
+
+        :return: order of the interpolation polynomial
+        """
+        return cls._POLYNOMIAL_ORDER
+
+    def __init__(self, data_axis, data):
+        """Initialize the object as interpolator of the input data defined on the specified axis
+
+        :param data_axis: the axis of length N on which the data is defined
+        :param data: data defined as MxN array of M-dimensional values (e.g. state vectors or attitude angles)
+        """
+        self._data_axis = data_axis
+        self._num_of_data_components = data.shape[0]
+        self._num_of_polynomials = self._data_axis.size - self._POLYNOMIAL_ORDER
+
+        # Matrix of polynomials
+        self._pos = np.ndarray((self._num_of_polynomials, self._num_of_data_components), dtype=np.poly1d)
+        self._vel = np.ndarray((self._num_of_polynomials, self._num_of_data_components), dtype=np.poly1d)
+        self._acc = np.ndarray((self._num_of_polynomials, self._num_of_data_components), dtype=np.poly1d)
+        # Relative azimuth axis [s]
+        relative_axis = self._data_axis.get_relative_array()
+        self._data_axis_array = self._data_axis.get_array()
+        for poly_index in range(self._num_of_polynomials):
+            # Each polynomial domain is defined by the poly_axis
+            poly_axis = relative_axis[poly_index : poly_index + self._DATA_POINTS_PER_POLY]
+
+            # Each polynomial relative axis starts at the start of the interval:
+            # P(t) = c0 + c1 * (t-poly_time_axis[0]) + ...
+            vandermonde_matrix = np.vander((poly_axis - poly_axis[0]).astype(float))
+
+            # Computation of polynomial coefficients
+            for component_index in range(self._num_of_data_components):
+                values = data[
+                    component_index,
+                    poly_index : poly_index + self._DATA_POINTS_PER_POLY,
+                ]
+                coefficients = np.linalg.solve(vandermonde_matrix, values).tolist()
+                position = np.poly1d(coefficients)
+                self._pos[poly_index, component_index] = position
+                self._vel[poly_index, component_index] = np.polyder(position, 1)
+                self._acc[poly_index, component_index] = np.polyder(position, 2)
+
+    @check_eval_function_input
+    def eval(self, interpolation_axis, interval_indexes, components_to_interpolate=None):
+        """Interpolate the data on the given interpolation axis
+
+        :param interpolation_axis: interpolation axis
+        :param interval_indexes: vector or single scalar or None. Denotes the intervals where the given interpolation
+        points are expected
+        :param components_to_interpolate: list of the components to interpolate, identified by their
+        index [optional]
+
+        :return: CxP array of interpolated values, where C is the number of interpolated components and P is the length
+        of the interpolation axis
+        """
+        return self._eval(interpolation_axis, interval_indexes, self._pos, components_to_interpolate)
+
+    @check_eval_function_input
+    def eval_first_derivative(self, interpolation_axis, interval_indexes, components_to_interpolate=None):
+        """Interpolate the first derivative of the data on the given interpolation axis
+
+        :param interpolation_axis: interpolation axis
+        :param interval_indexes: vector or single scalar or None. Denotes the interval where the given interpolation
+        points are expected
+        :param components_to_interpolate: list of the components to interpolate, identified by their index [optional]
+
+        :return: CxP array of interpolated values, where C is the number of interpolated components and P is the length
+        of the interpolation axis
+        """
+        return self._eval(interpolation_axis, interval_indexes, self._vel, components_to_interpolate)
+
+    @check_eval_function_input
+    def eval_second_derivative(self, interpolation_axis, interval_indexes, components_to_interpolate=None):
+        """Interpolate the second derivative of the data on the given interpolation axis
+
+        :param interpolation_axis: interpolation axis
+        :param interval_indexes: vector or single scalar or None. Denotes the interval where the given interpolation
+        points are expected
+        :param components_to_interpolate: list of the components to interpolate, identified by their index [optional]
+
+        :return: CxP array of interpolated values, where C is the number of interpolated components and P is the length
+        of the interpolation axis
+        """
+
+        return self._eval(interpolation_axis, interval_indexes, self._acc, components_to_interpolate)
+
+    def _eval(
+        self,
+        interpolation_axis,
+        interval_indexes,
+        polynomial,
+        components_to_interpolate=None,
+    ):
+        """Interpolate the data on the given interpolation axis by evaluating interpolation
+        polynomials (or a their modified version) on the interpolation axis
+
+        :param interpolation_axis: interpolation axis
+        :param interval_indexes: vector or single scalar or None. Denotes the interval where the given time is expected
+        :param polynomial: interpolation polynomials to evaluate
+        :param components_to_interpolate: list of the components to interpolate, identified by their index [optional]
+
+        :return: CxP array of interpolated values, where C is the number of interpolated components and P is the length
+        of the interpolation axis
+        """
+
+        if components_to_interpolate is None:
+            components_to_interpolate = range(self._num_of_data_components)
+
+        poly_indexes = self.get_polynomial_index(
+            interpolation_points=interpolation_axis, interval_indexes=interval_indexes
+        )
+
+        interpolation_results = np.zeros((len(components_to_interpolate), interpolation_axis.size))
+
+        for interpolation_point_index, (poly_index, interpolation_point) in enumerate(
+            zip(poly_indexes, interpolation_axis)
+        ):
+            interpolation_point_poly_rel = interpolation_point - self._data_axis_array[poly_index]
+
+            for out_component_index, component_index in enumerate(components_to_interpolate):
+                interpolation_results[out_component_index, interpolation_point_index] = polynomial[
+                    poly_index, component_index
+                ](interpolation_point_poly_rel)
+
+        return interpolation_results
+
+    def get_interval_index(self, interpolation_points):
+        """Get the indexes of the intervals where the interpolation_points lie
+
+        :param interpolation_points: vector of required interpolation points
+
+        :return: array of interval indexes
+        """
+        return self._data_axis.get_interval_id(interpolation_points)
+
+    def get_polynomial_index(self, interpolation_points=None, interval_indexes=None):
+        """Get the indexes of the polynomials to be used for interpolation
+
+        :param interpolation_points: vector of required interpolation points
+        :param interval_indexes: interval indexes of the interpolation points
+
+        :return: array of polynomial indexes
+
+        If interpolation points are specified, the positions on the interpolation axis are computed internally to find
+        the corresponding polynomial indexes;
+        If the interval indexes of the interpolation points on the axis are given, the polynomial indexes are computed
+        directly (ignoring the interpolation points).
+        """
+        if interval_indexes is None:
+            if interpolation_points is not None:
+                interval_indexes = self._data_axis.get_interval_id(interpolation_points)
+            else:
+                raise RuntimeError("Specify either interpolation points or interval indexes")
+        if isinstance(interval_indexes, int):
+            interval_indexes = np.asarray([interval_indexes])
+        return np.clip(
+            interval_indexes - self._POLY_CENTER_REL_INTERVAL_INDEX,
+            0,
+            self._num_of_polynomials - 1,
+        )
+
+    @property
+    def num_of_polynomials(self):
+        return self._num_of_polynomials