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
__all__
module-attribute
__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
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
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
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
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
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
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
__all__ = ['inverse_geocoding_bistatic', 'inverse_geocoding_monostatic', 'inverse_geocoding_monostatic_init', 'inverse_geocoding_monostatic_with_attitude']
Classes
Functions:
inverse_geocoding_monostatic
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
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
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
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
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
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
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
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:
- 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
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:
- 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
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
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
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:
- 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 |