Skip to content

API

Direct Geocoding

Direct Geocoding module.

This module provides high-level direct geocoding functions for computing ground point coordinates from sensor state vectors at given sensor times. It supports both monostatic (single sensor) and bistatic (separate transmitter/receiver) configurations.

Direct geocoding solves the intersection of the range-Doppler-ellipsoid system to find the Earth surface point corresponding to given sensor times. The equations are solved via Newton iterations.

All functions support vectorized operations on (N, 3) coordinate arrays and handle both scalar and array inputs for range times and Doppler frequencies. The WGS84 ellipsoid is used as the Earth model with configurable altitude offsets.

Look direction is specified as RIGHT or LEFT to determine the geocoding side relative to the sensor velocity vector.

Attributes

SensorLookDirection module-attribute

Python
SensorLookDirection = Literal['RIGHT', 'LEFT']

__all__ module-attribute

Python
__all__ = ['SensorLookDirection', 'direct_geocoding_bistatic', 'direct_geocoding_init', 'direct_geocoding_monostatic', 'direct_geocoding_with_look_angles', 'direct_geocoding_with_looking_direction', 'direct_geocoding_with_pointing']

Functions:

direct_geocoding_with_looking_direction

Python
direct_geocoding_with_looking_direction(sensor_positions: NDArray[floating], looking_directions: NDArray[floating], altitude: float = 0.0) -> npt.NDArray[np.floating]

Compute the ground points seen with the given looking directions.

The looking direction defines a line: its norm and sign do not matter.

Based on [compute_line_ellipsoid_intersections][ perseo_core.geometry.coordinates.ellipsoid.compute_line_ellipsoid_intersections ].

Parameters:

Name Type Description Default
sensor_positions NDArray[floating]

sensor positions with shape (3,) or (N, 3)

required
looking_directions NDArray[floating]

vectors aligned with a looking direction with shape (3,) or (N, 3)

required
altitude float

altitude with respect to WGS84 ellipsoid, by default 0.0

0.0

Returns:

Type Description
NDArray[floating]

ground points with shape (3,) or (N, 3), np.nan is a place-holder in case of impossible geocoding

direct_geocoding_with_look_angles

Python
direct_geocoding_with_look_angles(sensor_positions: NDArray[floating], sensor_velocities: NDArray[floating], reference_frame: ReferenceFrame, look_angles: float | NDArray[floating], altitude: float = 0.0) -> npt.NDArray[np.floating]

Compute the points at a given altitude over WGS84 ellipsoid seen with the given look angles.

Based on [direct_geocoding_with_looking_direction][ perseo_core.geometry.geocoding.direct.direct_geocoding_with_looking_direction ].

Parameters:

Name Type Description Default
sensor_positions NDArray[floating]

sensor positions with shape (3,) or (N, 3)

required
sensor_velocities NDArray[floating]

sensor velocities with shape (3,) or (N, 3)

required
reference_frame ReferenceFrame

reference frames oriented so that look angles are measured relative to the nadir direction

required
look_angles float | NDArray[floating]

look angles in radians, scalar or (N,)

required
altitude float

altitude with respect to WGS84 ellipsoid, by default 0.0

0.0

Returns:

Type Description
NDArray[floating]

ground points with shape (3,) or (N, 3), np.nan is a place-holder in case of impossible geocoding

direct_geocoding_with_pointing

Python
direct_geocoding_with_pointing(sensor_positions: NDArray[floating], antenna_reference_frames: NDArray[floating], azimuth_antenna_angles: float | NDArray[floating], elevation_antenna_angles: float | NDArray[floating], altitude: float = 0.0) -> npt.NDArray[np.floating]

Compute ground points illuminated with the given antenna patterns angles.

Parameters:

Name Type Description Default
sensor_positions NDArray[floating]

sensor positions, with shape (3,) or (N, 3)

required
antenna_reference_frames NDArray[floating]

antenna reference frames as a numpy array, with shape (3, 3) or (N, 3, 3)

required
azimuth_antenna_angles float | NDArray[floating]

scalar or (N,), in radians

required
elevation_antenna_angles float | NDArray[floating]

scalar or (N,), in radians

required
altitude float

altitude with respect to WGS84 ellipsoid, by default 0.0

0.0

Returns:

Type Description
NDArray[floating]

ground points (3,) or (N, 3) numpy array

direct_geocoding_monostatic

Python
direct_geocoding_monostatic(sensor_positions: NDArray[floating], sensor_velocities: NDArray[floating], range_times: float | NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float, look_direction: SensorLookDirection, altitude: float, initial_guesses: NDArray[floating] | None = None) -> npt.NDArray[np.floating]

Perform monostatic direct geocoding.

Parameters:

Name Type Description Default
sensor_positions NDArray[floating]

position of the sensor with shape (3,) or (N, 3)

required
sensor_velocities NDArray[floating]

velocity of the sensor with shape (3,) or (N, 3)

required
range_times float | NDArray[floating]

range times scalar or (M,)

required
doppler_frequencies float | NDArray[floating]

doppler frequencies scalar or array (M,)

required
wavelength float

carrier signal wavelength

required
look_direction SensorLookDirection

geocoding side, "RIGHT" or "LEFT"

required
altitude float

altitude with respect to WGS84 ellipsoid

required
initial_guesses NDArray[floating] | None

initial guess for Newton method. If not provided a guess will be computed, by default None

None

Returns:

Type Description
NDArray[floating]

ground points with shape (N, M, 3)

direct_geocoding_bistatic

Python
direct_geocoding_bistatic(sensor_positions_rx: NDArray[floating], sensor_velocities_rx: NDArray[floating], sensor_positions_tx: NDArray[floating], sensor_velocities_tx: NDArray[floating], range_times: float | NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float, look_direction: SensorLookDirection, altitude: float, initial_guesses: NDArray[floating] | None = None) -> npt.NDArray[np.floating]

Perform direct geocoding for bistatic sensors.

Parameters:

Name Type Description Default
sensor_positions_rx NDArray[floating]

position of the receiver with shape (3,) or (N, 3)

required
sensor_velocities_rx NDArray[floating]

velocity of the receiver with shape (3,) or (N, 3)

required
sensor_positions_tx NDArray[floating]

position of the transmitter with shape (3,) or (M, 3), where M is the number of range times

required
sensor_velocities_tx NDArray[floating]

velocity of the transmitter with shape (3,) or (M, 3), where M is the number of range times

required
range_times float | NDArray[floating]

range times scalar or shape (M,)

required
doppler_frequencies float | NDArray[floating]

doppler frequencies scalar or shape (M,)

required
wavelength float

carrier signal wavelength

required
look_direction SensorLookDirection

geocoding side, "RIGHT" or "LEFT"

required
altitude float

altitude with respect to the WGS84 ellipsoid

required
initial_guesses NDArray[floating] | None

initial guess for Newton iterations. If not provided a guess will be computed, by default None

None

Returns:

Type Description
NDArray[floating]

ground points with shape (N, M, 3)

direct_geocoding_init

Python
direct_geocoding_init(sensor_positions: NDArray[floating], sensor_velocities: NDArray[floating], range_distance: float, look_direction: SensorLookDirection) -> npt.NDArray[np.floating]

Compute initial guesses for direct geocoding, monostatic approximation.

Parameters:

Name Type Description Default
sensor_positions NDArray[floating]

sensor positions with shape (3,) or (N, 3)

required
sensor_velocities NDArray[floating]

sensor velocities with shape (3,) or (N, 3)

required
range_distance float

range distance

required
look_direction SensorLookDirection

side where to perform geocoding, "RIGHT" or "LEFT"

required

Returns:

Type Description
NDArray[floating]

guess ground points with shape (3,) or (N, 3)

Inverse Geocoding

Inverse Geocoding module.

This module provides high-level inverse geocoding functions for computing sensor times (azimuth time, range time) from known ground point coordinates. Inverse geocoding is the reverse operation of direct geocoding, solving for the acquisition geometry that observes a specific Earth surface location.

The module supports both monostatic (single sensor) and bistatic (separate transmitter/receiver) configurations, using Newton iterations to solve the system of equations.

All functions support vectorized operations on (N, 3) ground point arrays and handle both scalar and array inputs for Doppler frequencies. The Trajectory interface allows flexible sensor path representations while PreciseDateTime ensures precise time handling.

Attributes

__all__ module-attribute

Python
__all__ = ['inverse_geocoding_bistatic', 'inverse_geocoding_monostatic', 'inverse_geocoding_monostatic_init', 'inverse_geocoding_monostatic_with_attitude']

Classes

Functions:

inverse_geocoding_monostatic

Python
inverse_geocoding_monostatic(trajectory: Trajectory, ground_points: NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float, az_initial_time_guesses: PreciseDateTime | datetime64 | NDArray | None = None, init_guess_search_time_step: float | None = None) -> tuple[PreciseDateTime | np.datetime64 | npt.NDArray, float | npt.NDArray[np.floating]]

Monostatic inverse geocoding computation.

Initial guesses

One between az_initial_time_guesses and init_guess_search_time_step inputs must be provided.

Parameters:

Name Type Description Default
trajectory Trajectory

sensor trajectory

required
ground_points NDArray[floating]

ground points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
doppler_frequencies float | NDArray[floating]

doppler frequencies centroid values to perform the inverse geocoding, in the form float or (N,). the number of frequencies must be 1 or equal to the number of points provided (if more than 1). If just 1 ground point is provided, several frequencies can be given to compute inverse geocoding at each different input value

required
wavelength float

carrier signal wavelength

required
az_initial_time_guesses PreciseDateTime | datetime64 | NDArray | None

azimuth times initial guesses to limit and guide the search of solutions, in the form (N,) or as a single time. If None, it is automatically computed, by default None

None
init_guess_search_time_step float | None

if an azimuth initial guess for the Newton method is not provided, this parameter will be used to generate a time axis with this time step and the same time domain as the input trajectory to automatically compute the guess, the same step is used for both trajectories, by default None

None

Returns:

Type Description
PreciseDateTime | datetime64 | NDArray

azimuth times array

float | NDArray[floating]

range times array

inverse_geocoding_monostatic_with_attitude

Python
inverse_geocoding_monostatic_with_attitude(trajectory: Trajectory, attitude: Attitude, ground_points: NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float, dt: float = 0.1, az_initial_time_guesses: PreciseDateTime | datetime64 | NDArray | None = None, init_guess_search_time_step: float | None = None) -> tuple[PreciseDateTime | np.datetime64 | npt.NDArray, float | npt.NDArray[np.floating]]

Monostatic inverse geocoding with attitude computation.

Initial guesses

One between az_initial_time_guesses and init_guess_search_time_step inputs must be provided.

Parameters:

Name Type Description Default
trajectory Trajectory

sensor trajectory

required
attitude Attitude

sensor attitude

required
ground_points NDArray[floating]

ground points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
doppler_frequencies float | NDArray[floating]

doppler frequencies centroid values to perform the inverse geocoding, in the form float or (N,). the number of frequencies must be 1 or equal to the number of points provided (if more than 1). If just 1 ground point is provided, several frequencies can be given to compute inverse geocoding at each different input value

required
wavelength float

carrier signal wavelength

required
dt float

time step for computing the approximate derivative of the boresight normal unit vector, by default 0.1

0.1
az_initial_time_guesses PreciseDateTime | datetime64 | NDArray | None

azimuth times initial guesses to limit and guide the search of solutions, in the form (N,) or as a single time. If None, it is automatically computed, by default None

None
init_guess_search_time_step float | None

if an azimuth initial guess for the Newton method is not provided, this parameter will be used to generate a time axis with this time step and the same time domain as the input trajectory to automatically compute the guess, the same step is used for both trajectories, by default None

None

Returns:

Type Description
PreciseDateTime | datetime64 | NDArray

azimuth times array

float | NDArray[floating]

range times array

inverse_geocoding_monostatic_init

Python
inverse_geocoding_monostatic_init(trajectory: Trajectory, ground_points: NDArray[floating], time_axis: NDArray, doppler_frequencies: float | NDArray[floating], wavelength: float) -> PreciseDateTime | np.datetime64 | npt.NDArray

Compute azimuth initial guess for Newton method for monostatic inverse geocoding.

In principle each input ground point could be seen several times by the orbit if it contains multiple periods. In this case, only the first occurrence is taken, i.e. the solution corresponding to the first period (the smallest in terms of time).

If all the occurrences are needed, please refer to inverse_geocoding_monostatic_init_core in geocoding/inverse_geocoding_core instead, and perform the inverse geocoding operation providing the initial guesses as inputs.

Parameters:

Name Type Description Default
trajectory Trajectory

sensor trajectory

required
ground_points NDArray[floating]

ground points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
time_axis NDArray

sensor trajectory time axis array

required
doppler_frequencies float | NDArray[floating]

doppler frequencies centroid values to perform the inverse geocoding, in the form float or (N,). the number of frequencies must be 1 or equal to the number of points provided (if more than 1). If just 1 ground point is provided, several frequencies can be given to compute inverse geocoding at each different input value

required
wavelength float

carrier signal wavelength

required

Returns:

Type Description
PreciseDateTime | datetime64 | NDArray

azimuth times initial guesses, one for each input point

inverse_geocoding_bistatic

Python
inverse_geocoding_bistatic(trajectory_rx: Trajectory, trajectory_tx: Trajectory, ground_points: NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float, az_initial_time_guesses: PreciseDateTime | datetime64 | NDArray | None = None, init_guess_search_time_step: float | None = None) -> tuple[PreciseDateTime | np.datetime64 | npt.NDArray, float | npt.NDArray[np.floating]]

Bistatic inverse geocoding computation.

Initial guesses

One between az_initial_time_guesses and init_guess_search_time_step inputs must be provided.

Parameters:

Name Type Description Default
trajectory_rx Trajectory

receiving sensor trajectory

required
trajectory_tx Trajectory

transmitting sensor trajectory

required
ground_points NDArray[floating]

ground points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
doppler_frequencies float | NDArray[floating]

doppler frequencies centroid values to perform the inverse geocoding, in the form float or (N,). the number of frequencies must be 1 or equal to the number of points provided (if more than 1). If just 1 ground point is provided, several frequencies can be given to compute inverse geocoding at each different input value

required
wavelength float

carrier signal wavelength

required
az_initial_time_guesses PreciseDateTime | datetime64 | NDArray | None

azimuth times initial guesses to limit and guide the search of solutions, in the form (N,) or as a single time. If None, it is automatically computed, by default None

None
init_guess_search_time_step float | None

if an azimuth initial guess for the Newton method is not provided, this parameter will be used to generate a time axis with this time step and the same time domain as the input trajectory to automatically compute the guess, the same step is used for both trajectories, by default None

None

Returns:

Type Description
PreciseDateTime | datetime64 | NDArray

azimuth times array

float | NDArray[floating]

range times array

Raises:

Type Description
RuntimeError

if the input sensors' trajectories are overlapping

Core implementation

Direct geocoding core utilities.

Attributes

Functions:

direct_geocoding_monostatic_core

Python
direct_geocoding_monostatic_core(sensor_positions: NDArray[floating], sensor_velocities: NDArray[floating], range_times: float | NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float, altitude: float, initial_guesses: NDArray[floating]) -> npt.NDArray[np.floating]

Compute ground points via monostatic direct geocoding.

It supports N different sensor positions and M different range time values.

Parameters:

Name Type Description Default
sensor_positions NDArray[floating]

sensor positions with shape (3,) or (N, 3)

required
sensor_velocities NDArray[floating]

sensor velocities with shape (3,) or (N, 3)

required
range_times float | NDArray[floating]

range times with shape float or (M,)

required
doppler_frequencies float | NDArray[floating]

frequency_doppler_centroid value, single value or array (M,)

required
wavelength float

carrier signal wavelength

required
altitude float

altitude with respect to WGS84 ellipsoid

required
initial_guesses NDArray[floating]

initial guess for the Newton method, with shape (3,) or (N, 3) or (M, 3)

required

Returns:

Type Description
NDArray[floating]

ground points with shape (N, M, 3)

direct_geocoding_monostatic_core_range_vectorized

Python
direct_geocoding_monostatic_core_range_vectorized(sensor_positions: NDArray[floating], sensor_velocities: NDArray[floating], range_times: float | NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float, altitude: float, initial_guesses: NDArray[floating]) -> npt.NDArray[np.floating]

Perform direct geocoding for monostatic systems, vectorized computation along range times.

Parameters:

Name Type Description Default
sensor_positions NDArray[floating]

sensor positions with shape (3,) or (N, 3)

required
sensor_velocities NDArray[floating]

sensor velocities with shape (3,) or (N, 3)

required
range_times float | NDArray[floating]

range times with shape float or (M,)

required
doppler_frequencies float | NDArray[floating]

frequency_doppler_centroid value, single value or array (M,)

required
wavelength float

carrier signal wavelength

required
altitude float

altitude with respect to WGS84 ellipsoid

required
initial_guesses NDArray[floating]

initial guess for the Newton method, with shape (3,) or (N, 3) or (M, 3)

required

Returns:

Type Description
NDArray[floating]

ground points with shape (N, M, 3)

direct_geocoding_bistatic_core

Python
direct_geocoding_bistatic_core(sensor_positions_rx: NDArray[floating], sensor_velocities_rx: NDArray[floating], sensor_positions_tx: NDArray[floating], sensor_velocities_tx: NDArray[floating], range_times: float | NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float, altitude: float, initial_guesses: NDArray[floating]) -> npt.NDArray[np.floating]

Compute ground points via bistatic direct geocoding.

Parameters:

Name Type Description Default
sensor_positions_rx NDArray[floating]

position of the receiver, with shape (3,) or (N, 3)

required
sensor_velocities_rx NDArray[floating]

velocities of the receiver, with shape (3,) or (N, 3)

required
sensor_positions_tx NDArray[floating]

position of the transmitter, with shape (3,) or (M, 3), where M is the number of range times

required
sensor_velocities_tx NDArray[floating]

velocities of the transmitter, with shape (3,) or (M, 3), where M is the number of range times

required
range_times float | NDArray[floating]

range times with shape float or (M,)

required
doppler_frequencies float | NDArray[floating]

frequency_doppler_centroid value, single value or array (M,)

required
wavelength float

carrier signal wavelength

required
altitude float

altitude with respect to WGS84 ellipsoid

required
initial_guesses NDArray[floating]

initial guess for Newton method, with shape (3,), (N, 3) or (M, 3)

required

Returns:

Type Description
NDArray[floating]

ground points with shape (N, M, 3)

Inverse geocoding core utilities.

Classes

Functions:

inverse_geocoding_monostatic_core

Python
inverse_geocoding_monostatic_core(trajectory: Trajectory, ground_points: NDArray[floating], initial_guesses: PreciseDateTime | datetime64 | NDArray, doppler_frequencies: float | NDArray[floating], wavelength: float, scene_velocity: NDArray[floating] | None = None, abs_time_tolerance: float = 1e-08, max_iter: int = 8) -> tuple[PreciseDateTime | np.datetime64 | npt.NDArray, float | npt.NDArray[np.floating]]

Core algorithm for precise inverse geocoding monostatic.

This function finds one zero of the doppler equation as a function of the azimuth time. The search of the zero is restricted to the interval associated to the polynomial indexed by polynomial_index. Newton iterations are performed to find the exact azimuth time, once that the sensor position is known the computation of the range time is trivial.

Vectorized function with the following supported cases:

Text Only
- 1 guess and 1 earth point --> PDT, float
- N guesses and N earth points --> array[PDT], array[float]
- 1 guess and N earth points --> array[PDT], array[float]
- N guesses and 1 earth point --> array[PDT], array[float]
- N earth points and N frequencies and 1 guess --> array[PDT], array[float]
- N earth points and N frequencies and N guess --> array[PDT], array[float]
- 1 earth point and N frequencies and N guess --> array[PDT], array[float]
- 1 earth point and N frequencies and 1 guess --> array[PDT], array[float]

Parameters:

Name Type Description Default
trajectory Trajectory

sensor trajectory

required
ground_points NDArray[floating]

ground points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
initial_guesses PreciseDateTime | datetime64 | NDArray

azimuth times initial guesses to limit and guide the search of solutions, in the form (N,) or as a single time

required
doppler_frequencies float | NDArray[floating]

doppler frequencies centroid values to perform the inverse geocoding, in the form float or (N,). the number of frequencies must be 1 or equal to the number of points provided (if more than 1). If just 1 ground point is provided, several frequencies can be given to compute inverse geocoding at each different input value

required
wavelength float

carrier signal wavelength

required
scene_velocity NDArray[floating] | None

ground scene velocity. If None, it's set to the default value of 0, by default None

None
abs_time_tolerance float

absolute time tolerance for newton convergence criteria, by default 1e-8

1e-08
max_iter int

maximum number of iterations for newton method, by default 8

8

Returns:

Type Description
PreciseDateTime | datetime64 | NDArray

azimuth times array

float | NDArray[floating]

range times array

Raises:

Type Description
RuntimeError

ambiguous association between N ground points and M init guesses

RuntimeError

ambiguous association between N ground points and M frequencies

RuntimeError

Newton method could not converge

inverse_geocoding_bistatic_core

Python
inverse_geocoding_bistatic_core(trajectory_rx: Trajectory, trajectory_tx: Trajectory, ground_points: NDArray[floating], initial_guesses: PreciseDateTime | datetime64 | NDArray, doppler_frequencies: float | NDArray[floating], wavelength: float, abs_time_tolerance: float = 1e-08, max_iter: int = 8) -> tuple[PreciseDateTime | np.datetime64 | npt.NDArray, float | npt.NDArray[np.floating]]

Core algorithm for precise inverse geocoding bistatic.

Vectorized function with the following supported cases:

Text Only
- 1 guess and 1 earth point --> PDT, float
- N guesses and N earth points --> array[PDT], array[float]
- 1 guess and N earth points --> array[PDT], array[float]
- N guesses and 1 earth point --> array[PDT], array[float]
- N guesses and N frequencies --> array[PDT], array[float]
- N earth points and N frequencies and 1 guess --> array[PDT], array[float]
- N earth points and N frequencies and N guess --> array[PDT], array[float]
- 1 earth point and N frequencies and N guess --> array[PDT], array[float]
- 1 earth point and N frequencies and 1 guess --> array[PDT], array[float]

Parameters:

Name Type Description Default
trajectory_rx Trajectory

receiving sensors trajectory

required
trajectory_tx Trajectory

transmitting sensor trajectory

required
ground_points NDArray[floating]

ground points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
initial_guesses PreciseDateTime | datetime64 | NDArray

azimuth times initial guesses to limit and guide the search of solutions, in the form (N,) or as a single time

required
doppler_frequencies float | NDArray[floating]

doppler frequencies centroid values to perform the inverse geocoding, in the form float or (N,). the number of frequencies must be 1 or equal to the number of points provided (if more than 1). If just 1 ground point is provided, several frequencies can be given to compute inverse geocoding at each different input value

required
wavelength float

carrier signal wavelength

required
abs_time_tolerance float

absolute time tolerance for newton convergence criteria, by default 1e-8

1e-08
max_iter int

maximum number of iterations for newton method, by default 8

8

Returns:

Type Description
PreciseDateTime | datetime64 | NDArray

azimuth times array

float | NDArray[floating]

range times array

Raises:

Type Description
RuntimeError

ambiguous association between N ground points and M init guesses

RuntimeError

ambiguous association between N ground points and M frequencies

RuntimeError

Newton method could not converge

inverse_geocoding_monostatic_init_core

Python
inverse_geocoding_monostatic_init_core(trajectory: Trajectory, time_axis: NDArray, ground_points: NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float) -> list[npt.NDArray]

Compute initial guess for Newton method for monostatic inverse geocoding.

The azimuth time we are looking for is such that the doppler equation is equal to zero. In this function we look for the time interval where such equation crosses zero. We compute the corresponding polynomial index that will be used subsequently for the precise computation of the azimuth time. This function evaluates the doppler equation on the azimuth time axis of the gso. It checks where it changes sign (from plus to minus). For each of those time positions the index of polynomial to use for interpolating in that neighborhood is computed and returned. If no crossing points are found, either the first or the last polynomials ids are returned depending on the time instants that has smaller values of the doppler equation.

In principle each input ground point could be seen several times by the sensor orbit if it contains multiple periods. In this case, all possible solutions are kept and returned in a list with an array for each input point and the size of the array matches the number of solutions found for that point.

Parameters:

Name Type Description Default
trajectory Trajectory

sensor trajectory

required
time_axis ndarray

trajectory's time axis array

required
ground_points NDArray[floating]

ground points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
doppler_frequencies float | NDArray[floating]

doppler frequencies centroid values to perform the inverse geocoding, in the form float or (N,). the number of frequencies must be 1 or equal to the number of points provided (if more than 1). If just 1 ground point is provided, several frequencies can be given to compute inverse geocoding at each different input value

required
wavelength float

carrier signal wavelength

required

Returns:

Type Description
list[NDArray]

list of azimuth times initial guesses arrays, one for each input ground point

inverse_geocoding_bistatic_init_core

Python
inverse_geocoding_bistatic_init_core(trajectory_rx: Trajectory, trajectory_tx: Trajectory, time_axis_rx: NDArray, time_axis_tx: NDArray, ground_points: NDArray[floating], doppler_frequencies: float | NDArray[floating], wavelength: float) -> PreciseDateTime | np.datetime64 | npt.NDArray

Compute azimuth initial guess for Newton method for bistatic inverse geocoding.

Parameters:

Name Type Description Default
trajectory_rx Trajectory

receiving sensor trajectory

required
trajectory_tx Trajectory

transmitting sensor trajectory

required
time_axis_rx NDArray

receiving sensor trajectory time axis array

required
time_axis_tx NDArray

transmitting sensor trajectory time axis array

required
ground_points NDArray[floating]

ground points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
doppler_frequencies float | NDArray[floating]

doppler frequencies centroid values to perform the inverse geocoding, in the form float or (N,). the number of frequencies must be 1 or equal to the number of points provided (if more than 1). If just 1 ground point is provided, several frequencies can be given to compute inverse geocoding at each different input value

required
wavelength float

carrier signal wavelength

required

Returns:

Type Description
PreciseDateTime | datetime64 | NDArray

azimuth times initial guesses

Raises:

Type Description
RuntimeError

ambiguous association between N ground points and M frequencies

RuntimeError

if orbit rx and orbit tx are not overlapped

inverse_geocoding_monostatic_attitude_core

Python
inverse_geocoding_monostatic_attitude_core(trajectory: Trajectory, attitude: Attitude, ground_points: NDArray[floating], initial_guesses: PreciseDateTime | datetime64 | NDArray, dt: float = 0.1, abs_time_tolerance: float = 1e-08, max_iter: int = 8) -> tuple[PreciseDateTime | np.datetime64 | npt.NDArray, float | npt.NDArray[np.floating]]

Core algorithm for precise inverse geocoding monostatic using attitude and 3D Differentiable curve objects.

Vectorized function with the following supported cases:

Text Only
- 1 guess and 1 earth point --> PDT, float
- N guesses and N earth points --> array[PDT], array[float]
- 1 guess and N earth points --> array[PDT], array[float]
- N guesses and 1 earth point --> array[PDT], array[float]

Parameters:

Name Type Description Default
trajectory Trajectory

sensor trajectory

required
attitude Attitude

sensor attitude

required
ground_points NDArray[floating]

earth points to inverse geocode in XYZ coordinates, in the form (3,) or (N, 3)

required
initial_guesses PreciseDateTime | datetime64 | NDArray

initial guesses for newton resolution method, initial guess can be a single PDT value or an array of PDT (N,)

required
dt float

time step for computing the approximate derivative of the boresight normal unit vector, by default 0.1

0.1
abs_time_tolerance float

absolute time tolerance for newton convergence criteria, by default 1e-8

1e-08
max_iter int

maximum number of iterations for newton method, by default 8

8

Returns:

Type Description
PreciseDateTime | datetime64 | NDArray

azimuth times array

float | NDArray[floating]

range times array

Raises:

Type Description
RuntimeError

ambiguous association between N input guesses and M earth points

RuntimeError

Newton method could not converge