Skip to content

API

Main Implementation

Point Target Analysis: IRF, RCS and Localization Errors

Attributes

Classes

Functions:

point_target_analysis

Python
point_target_analysis(product: QualityInputProduct, point_targets: list[PointTarget], config: PointTargetAnalysisConfig | None = None) -> tuple[pd.DataFrame, list[ptdt.PointTargetGraphicalData]]

Compute the full point target analysis: IRF, RCS and localization errors.

Parameters:

Name Type Description Default
product QualityInputProduct

object satisfying the QualityInputProduct protocol

 required
point_targets list[PointTarget]

list of point target locations as PointTarget objects

 required
config PointTargetAnalysisConfig

config file PointTargetAnalysisConfig dataclass to enable and manage different features, if provided, by default None

 None

Returns:

Type Description
DataFrame

pandas dataframe containing all the computed features for each point target
list[PointTargetGraphicalData]

list of PointTargetGraphicalData data output for plotting graphs

Raises:

Type Description
SideLobesDirectionsEstimationError

could not compute side lobes directions

point_target_analysis_single

Python
point_target_analysis_single(channel_data: ChannelData, burst: int, point_target: PointTarget, config: PointTargetAnalysisConfig) -> tuple[ptdt.PointTargetAnalysisOutput, ptdt.PointTargetGraphicalData]

Analysis of a single point target.

Parameters:

Name Type Description Default
channel_data ChannelData

current channel data

 required
burst int

current burst id

 required
point_target PointTarget

current point target to be analyzed

 required
config PointTargetAnalysisConfig

point target analysis configuration

 required

Returns:

Type Description
PointTargetAnalysisOutput

quantitative analysis results
PointTargetGraphicalData

additional data for graphical output generation

Raises:

Type Description
SideLobesDirectionsEstimationError

if there is an error in computing the side lobes direction

compute_sar_coordinates

Python
compute_sar_coordinates(target: PointTarget, channel_data: ChannelData, burst: int) -> gdt.SARCoordinates

Extract azimuth and range coordinates.

Parameters:

Name Type Description Default
target PointTarget

current point target nominal data

 required
channel_data ChannelData

current channel data

 required
burst int

burst id

 required

Returns:

Type Description
SARCoordinates

SAR coordinates of the current point target as seen by the SAR product

update_steps

Python
update_steps(azimuth_step: float, range_step: float, side_lobes_directions: SideLobesDirections, target_area_shape: tuple[int, ...]) -> tuple[float, float]

Update the azimuth and range steps for localization purposes due to side lobes directions.

Parameters:

Name Type Description Default
azimuth_step float

original azimuth step

 required
range_step float

original range step

 required
side_lobes_directions SideLobesDirections

range and azimuth cuts angular coefficients in samples

 required
target_area_shape tuple[int, ...]

target area shape

 required

Returns:

Type Description
float

updated azimuth step
float

updated range step

point_target_analysis_core_computation

Python
point_target_analysis_core_computation(target_area: ndarray, location_data: LocationData, target_pos_real: NDArray[floating], target_pos_nominal: NDArray[floating], sensor_position_at_target: NDArray[floating], side_lobes_directions: SideLobesDirections, projection: SARProjection, polarization: SARPolarization, carrier_frequency: float, original_range_step_m: float, original_azimuth_step_m: float, target_info: PointTarget, config: PointTargetAnalysisConfig) -> tuple[ptdt.IRFDataOutput, ptdt.RCSDataOutput, ptdt.IRFGraphDataOutput, ptdt.RCSGraphDataOutput]

Perform the core computation of the point target analysis.

Parameters:

Name Type Description Default
target_area ndarray

target area to be analyzed

 required
location_data LocationData

location data

 required
target_pos_real NDArray[floating]

real peak position of the target as detected by the SAR product

 required
target_pos_nominal NDArray[floating]

nominal target position

 required
sensor_position_at_target NDArray[floating]

sensor position in orbit at target location

 required
side_lobes_directions SideLobesDirections

range and azimuth cuts angular coefficients in samples

 required
projection SARProjection

SAR product projection

 required
polarization SARPolarization

SAR product polarization

 required
carrier_frequency float

signal carrier frequency

 required
original_range_step_m float

original range step in meters

 required
original_azimuth_step_m float

original azimuth step in meters

 required
target_info PointTarget

current target to be analyzed

 required
config PointTargetAnalysisConfig

point target analysis configuration

 required

Returns:

Type Description
IRFDataOutput

IRF analysis results
RCSDataOutput

RCS analysis results
IRFGraphDataOutput

data for IRF graphical output
RCSGraphDataOutput

data for RCS graphical output

irf_analysis_profiles

Python
irf_analysis_profiles(recentered_target_area_interp: ndarray, data_type: TargetDataType, range_step_m: float, azimuth_step_m: float, side_lobes_directions: SideLobesDirections) -> ptdt.IRFGraphDataOutput

Compute the IRF analysis profiles.

Parameters:

Name Type Description Default
recentered_target_area_interp ndarray

target area recentered on signal peak position

 required
data_type TargetDataType

data type

 required
range_step_m float

range step in meters

 required
azimuth_step_m float

azimuth step in meters

 required
side_lobes_directions SideLobesDirections

range and azimuth cuts angular coefficients in samples

 required

Returns:

Type Description
IRFGraphDataOutput

data for IRF graphical output

Raises:

Type Description
PointTargetComputationError

if IRF resolution could not be computed

rcs_analysis

Python
rcs_analysis(target_area: ndarray, target_pos_real: NDArray[floating], rcs_parameters: RCSParameters, polarization: SARPolarization, target_info: PointTarget, sensor_position_at_target: NDArray[floating], carrier_frequency: float, range_resolution_px: float, azimuth_resolution_px: float, step_distances: list[float]) -> tuple[ptdt.RCSDataOutput, ptdt.RCSGraphDataOutput]

Perform the RCS analysis.

Parameters:

Name Type Description Default
target_area ndarray

target area to be analyzed

 required
target_pos_real NDArray[floating]

real peak position of the target as detected by the SAR product

 required
rcs_parameters RCSParameters

rcs parameters

 required
polarization SARPolarization

SAR product polarization

 required
target_info PointTarget

current target to be analyzed

 required
sensor_position_at_target NDArray[floating]

sensor position in orbit at target location

 required
carrier_frequency float

signal carrier frequency

 required
range_resolution_px float

range resolution in pixels

 required
azimuth_resolution_px float

azimuth resolution in pixels

 required
step_distances list[float]

step distances

 required

Returns:

Type Description
RCSDataOutput

RCS analysis results
RCSGraphDataOutput

data for RCS graphical output

Point Target Analysis support functionalities

Attributes

Classes

Functions:

get_squint_angle

Python
get_squint_angle(channel_data: ChannelData, azimuth_time: PreciseDateTime, ground_point: NDArray[floating]) -> float

Compute squint angle (radians) for a given azimuth time and ground point.

Parameters:

Name Type Description Default
channel_data ChannelManager

ChannelManager instance

 required
azimuth_time PreciseDateTime

azimuth time at which compute the squint angle

 required
ground_point NDArray[floating]

ground point seen by the sensor at the provided azimuth time

 required

Returns:

Type Description
float

squint angle (rad)

get_doppler_centroid

Python
get_doppler_centroid(channel_data: ChannelData, azimuth_time: PreciseDateTime, ground_point: NDArray[floating]) -> float

Computing doppler centroid frequency from azimuth time and its corresponding squint angle.

Parameters:

Name Type Description Default
channel_data ChannelManager

ChannelManager instance

 required
azimuth_time PreciseDateTime

azimuth time at which compute doppler centroid frequency

 required
ground_point NDArray[floating]

ground point seen by the sensor at the provided azimuth time

 required

Returns:

Type Description
float

doppler centroid frequency (Hz)

compute_side_lobes_directions

Python
compute_side_lobes_directions(channel_data: ChannelData, peak_azimuth_time: PreciseDateTime, peak_range_time: float, azimuth_step_m: float) -> tuple[SideLobesDirections, float, float]

Computing side lobe directions for squinted data and squint angle.

Parameters:

Name Type Description Default
channel_data ChannelManager

ChannelManager instance

 required
peak_azimuth_time PreciseDateTime

azimuth time corresponding to the point target signal peak

 required
peak_range_time float

range time corresponding to the point target signal peak

 required

Returns:

Type Description
SideLobesDirections

range and azimuth cuts angular coefficients in samples
float

squint angle (rad)
float

doppler centroid (Hz)

Functions to generate plots for IRF and RCS analyses

Attributes

Classes

Functions:

point_target_graphs_generation

Python
point_target_graphs_generation(graphs_data: list[PointTargetGraphicalData], results_df: DataFrame, output_dir: str | Path | None, interactive: bool = False) -> None

Full Point Target Analysis output graphs generation.

Parameters:

Name Type Description Default
graphs_data list[PointTargetGraphicalData]

graphs data for plotting results

 required
results_df DataFrame

point target analysis results dataframe

 required
output_dir str | Path | None

path to output directory where to save the graphs, while interactive mode is on it is ignored so it can be passed as None

 required
interactive bool

if set to True, this flag will show the generated plots and will not dump to disk the graphs, by default False

 False

Raises:

Type Description
ValueError

if output directory is None and interactive flag is False

irf_graphs

Python
irf_graphs(data_graph: IRFGraphDataOutput, data_values: dict, graphs_info: PTAGraphsInfo, out_dir: Path | None, interactive: bool = False) -> None

Function to generate the graphical output after IRF analysis.

Parameters:

Name Type Description Default
data_graph IRFGraphDataOutput

dataclass instance containing all relevant data for plotting results

 required
data_values dict

dictionary of IRF results

 required
graphs_info PTAGraphsInfo

info for graphs labelling

 required
out_dir Path | None

output folder path, while interactive mode is on it is ignored so it can be passed as None

 required
interactive bool

if set to True, this flag will show the generated plots and will not dump to disk the graphs, by default False

 False

Raises:

Type Description
ValueError

if output directory is None and interactive flag is False

rcs_graphs

Python
rcs_graphs(data_graph: RCSGraphDataOutput, graphs_info: PTAGraphsInfo, out_dir: Path | None, interactive: bool = False) -> None

Function to generate the graphical output after RCS analysis.

Parameters:

Name Type Description Default
data_graph RCSGraphDataOutput

dataclass instance containing all relevant data for plotting results

 required
graphs_info PTAGraphsInfo

info for graphs labelling

 required
out_dir Path | None

output folder path, while interactive mode is on it is ignored so it can be passed as None

 required
interactive bool

if set to True, this flag will show the generated plots and will not dump to disk the graphs, by default False

 False

Raises:

Type Description
ValueError

if output directory is None and interactive flag is False

Radar Cross Section (RCS) Geometric Estimation for Corner Reflectors.

Functions:

compute_rcs_trihedral_corner_reflector

Python
compute_rcs_trihedral_corner_reflector(cr_arm_length_m: float, wavelength_m: float, elevation_rad: NDArray[floating], azimuth_rad: NDArray[floating]) -> npt.NDArray[np.floating]

Computes the Radar Cross Section (RCS) of a trihedral corner reflector (CR) as observed by a radar source emitting at a certain wavelength. The function requires in input the size (arm length) of the CR, the frequency of the radar source, and the angular coordinates of the radar source as see by the corner reflector.

The angular coordinates (elevation and azimuth) are expressed in a reference frame such that the three axes are parallel to the trihedral CR edges, with the xy plane parallel to the horizontal plate, so that: - the elevation is the angle between the viewing direction and the x-y plane, assumed to be parallel to the horizontal plate of the CR - the azimuth is the angle between the x-axis and the projection of the viewing direction on the x-y plane

See Brock, Billy & Doerry, Armin. (2009). Radar cross section of triangular trihedral reflector with extended bottom plate. 10.2172/984946.

Parameters:

Name Type Description Default
cr_arm_length_m float

Length of the arm of the trihedral corner reflector, expressed in m

 required
wavelength_m float

Wavelength of the radio wave impinging on the corner reflector, expressed in m

 required
elevation_rad NDArray[floating]

Elevation angle at which the corner reflector sees the source of radio waves, expressed in radians

 required
azimuth_rad NDArray[floating]

Azimuth angle at which the corner reflector sees the source of radio waves, expressed in radians

 required

Returns:

Type Description
NDArray[floating]

Radar Cross Section (RCS) of the trihedral corner reflector, expressed in meters squared

compute_elevation_azimuth_wrt_enu

Python
compute_elevation_azimuth_wrt_enu(pos_cr: NDArray[floating], pos_sat: NDArray[floating]) -> tuple[float, float]

Computes the looking angles (elevation and azimuth) at which a point on ground (e.g. a corner reflector) sees another point in the sky (e.g. a satellite), with respect to its local ENU reference frame.

Letting rho be the normalized line of sight vector pointing from the corner reflector to the satellite, and letting e, n, and u, the unit vectors of the ENU reference frame local to the corner reflector, then the elevation angle and azimuth angle are, respectively:

\[ \begin{aligned} & E=\arcsin(\hat {\boldsymbol \rho}\cdot \hat{\mathbf u}) \\[10pt] & A=\arctan \left (\frac{\hat {\boldsymbol \rho}\cdot \hat{\mathbf e}}{\hat {\boldsymbol \rho}\cdot \hat{\mathbf n}}\right ) \end{aligned} \]

N.B. elevation and azimuth here computed are expressed wrt local ENU reference frame, not wrt boresight

See https://gssc.esa.int/navipedia/index.php/Transformations_between_ECEF_and_ENU_coordinates

Parameters:

Name Type Description Default
pos_cr NDArray[floating]

numpy array, expressing the 3D Cartesian position of a corner reflector on ground, with shape (3,)

 required
pos_sat NDArray[floating]

numpy array, expressing the 3D Cartesian position of a satellite observing the corner reflector, with shape (3,)

 required

Returns:

Type Description
float

elevation angle in radians at which the corner reflector sees the satellite in its ENU local reference frame
float

azimuth angle in radians at which the corner reflector sees the satellite in its ENU local reference frame

Core Algorithms

Point Target Impulse Response Function computation

Attributes

Classes

Functions:

compute_point_target_irf_analysis

Python
compute_point_target_irf_analysis(recentered_target_area_interp: ndarray, range_resolution_px: float, azimuth_resolution_px: float, side_lobes_directions: SideLobesDirections | None = None, mask_method: MaskingMethod = MaskingMethod.PEAK, pslr_flag: bool = True, islr_flag: bool = True, sslr_flag: bool = True) -> IRFComputedParameters

Computing Point Target Impulse Response Function parameters: PSLR, ISLR and SSLR, if requested.

Parameters:

Name Type Description Default
recentered_target_area_interp ndarray

target area centered on point target signal peak, interpolated for higher resolution, with shape (n_rng, naz)

 required
range_resolution_px float

range resolution in pixels

 required
azimuth_resolution_px float

azimuth resolution in pixels

 required
side_lobes_directions SideLobesDirections

range and azimuth cuts angular coefficients in samples, by default (np.inf, 0.0)

 None
mask_method MaskingMethod

masking method for PSLR and ISLR computation, by default MaskingMethod.PEAK

 PEAK
pslr_flag bool

flag to enable PSLR computation, by default True

 True
islr_flag bool

flag to enable ISLR computation, by default True

 True
sslr_flag bool

flag to enable SSLR computation, by default True

 True

Returns:

Type Description
IRFComputedParameters

computed IRF parameters

compute_pslr_2d

Python
compute_pslr_2d(data: ndarray, resolution: tuple[float, float], mask: MaskingMethod = MaskingMethod.RESOLUTION, side_lobes_directions: SideLobesDirections = (np.inf, 0.0)) -> tuple[float, float, float]

Compute the PSLR (Peak-to-Side-Lobe-Ratio) of the given input 2D array.

Parameters:

Name Type Description Default
data ndarray

input 2D array to compute PSLR onto, with shape (n_rng, n_az)

 required
resolution tuple[float, float]

range [0] and azimuth [1] resolutions in pixel

 required
mask MaskingMethod

masking generation method, by default MaskingMethod.RESOLUTION

 RESOLUTION
side_lobes_directions SideLobesDirections

range and azimuth cuts angular coefficients in samples, by default (np.inf, 0.0)

 (inf, 0.0)

Returns:

Type Description
float

range PSLR
float

azimuth PSLR
float

2D PSLR

compute_islr_2d

Python
compute_islr_2d(data: ndarray, resolution: tuple[float, float], mask: MaskingMethod = MaskingMethod.RESOLUTION, side_lobes_directions: SideLobesDirections = (np.inf, 0.0)) -> tuple[float, float, float]

Compute Integral-Side-Lobe-Ratio (ISLR).

Parameters:

Name Type Description Default
data ndarray

input 2D array to compute ISLR onto, with shape (n_rng, n_az)

 required
resolution tuple[float, float]

range [0] and azimuth [1] resolutions

 required
mask MaskingMethod

masking generation method, by default MaskingMethod.RESOLUTION

 RESOLUTION
side_lobes_directions SideLobesDirections

range and azimuth cuts angular coefficients in samples, by default np.array([np.inf, 0.0])

 (inf, 0.0)

Returns:

Type Description
float

range ISLR
float

azimuth ISLR
float

2D ISLR

compute_sslr_2d

Python
compute_sslr_2d(data: ndarray, resolution: tuple[float, float], side_lobes_directions: SideLobesDirections) -> tuple[float, float, float]

Compute Secondary-Side-Lobe-Ratio (SSLR).

Parameters:

Name Type Description Default
data ndarray

input 2D array to compute SSLR onto, with shape (n_rng, n_az)

 required
resolution tuple[float, float]

range [0] and azimuth [1] resolutions

 required
side_lobes_directions SideLobesDirections

range and azimuth cuts angular coefficients in samples

 required

Returns:

Type Description
float

range SSLR
float

azimuth SSLR
float

2D SSLR

Point Target Radar Cross Section computation

Attributes

Classes

Functions:

compute_point_target_rcs

Python
compute_point_target_rcs(target_area: ndarray, range_resolution_px: float, azimuth_resolution_px: float, target_pos_real: NDArray[floating], rcs_interp_factor: int, rcs_roi: NDArray[floating], k_lin: float = 1, s_f: float = 1) -> tuple[RCSDataOutput, np.ndarray, list, list]

Compute the Radar Cross-Section (RCS) from target acquisition data. Input data is considered: beta-nought, radiometrically corrected, absolutely calibrated (if k_lin=1) and not resampled (if s_f=1).

Parameters:

Name Type Description Default
target_area ndarray

target area where to compute the radar cross section, with shape (n_rng, n_az)

 required
range_resolution_px float

range resolution in pixels

 required
azimuth_resolution_px float

azimuth resolution in pixels

 required
target_pos_real ndarray

position of the signal peak in pixels, range_px[0] and azimuth_px[1]

 required
rcs_interp_factor int

rcs interpolation factor

 required
rcs_roi NDArray[floating]

region of interest for RCS computation

 required
k_lin float

a value of 1 means absolutely calibrated, by default 1

 1
s_f float

a value of 1 means not resampled, by default 1

 1

Returns:

Type Description
RCSDataOutput

dataclass object containing all computed export variables
ndarray

roi target data
list

background intensity corners, a list pixels for each square corner region
list

list of peak roi corner pixels

compute_additional_rcs_values

Python
compute_additional_rcs_values(rcs_input: RCSDataOutput, step_distances: list, interp_factor: int, polarization: SARPolarization, target_info: PointTarget, sensor_position: NDArray[floating], fc_hz: float) -> tuple[float, float, float, float]

Adjust rcs output values and calculate peak phase error.

Parameters:

Name Type Description Default
rcs_input RCSDataOutput

rcs output values from PointTargetIRF object

 required
step_distances list

step distances [range, azimuth]

 required
interp_factor int

rcs interpolation factor

 required
polarization EPolarization

polarization value [V/V, H/H, H/V, V/H]

 required
target_info PointTarget

target info as PointTarget

 required
sensor_position NDArray[floating]

satellite position at given azimuth time

 required
fc_hz float

carrier frequency

 required

Returns:

Type Description
tuple[float, float, float, float]

rcs linear, rcs [db], rcs error [db], peak phase error [deg]

Point Target Localization Error analysis module

Functions:

compute_localization_errors_pixels

Python
compute_localization_errors_pixels(target_pos_real: NDArray[floating], target_pos_ref: NDArray[floating]) -> tuple[float, float, float]

Compute localization errors for slant range, azimuth and ground range directions in pixels.

Parameters:

Name Type Description Default
target_pos_real NDArray[floating]

real target peak position identified in the raster data

 required
target_pos_ref NDArray[floating]

nominal reference target position as provided by the external calibration file

 required

Returns:

Type Description
float

slant range localization error in pixels
float

azimuth localization error in pixels
float

ground range localization error in pixels

Point Target Analysis Pre Processing computation

Attributes

Classes

Functions:

detect_data_type

Python
detect_data_type(target_area: ndarray) -> TargetDataType

Detecting target data type from the raster content.

Parameters:

Name Type Description Default
target_area ndarray

raster content

 required

Returns:

Type Description
TargetDataType

target data type of input raster data

compute_data_resolution_pixel

Python
compute_data_resolution_pixel(recentered_target_area_interp: ndarray, data_type: TargetDataType, side_lobes_directions: SideLobesDirections) -> tuple[np.ndarray, np.ndarray, float, float]

Compute data resolution in pixels along range and azimuth directions.

Parameters:

Name Type Description Default
recentered_target_area_interp ndarray

target area centered on point target signal peak, interpolated for higher resolution, with shape (n_rng, naz)

 required
data_type TargetDataType

target data type

 required
side_lobes_directions SideLobesDirections

range and azimuth cuts angular coefficients in samples

 required

Returns:

Type Description
ndarray

range profile
ndarray

azimuth profile
float

range resolution in pixels
float

azimuth resolution in pixels

target_area_interpolation

Python
target_area_interpolation(target_area: ndarray, target_pos_real: tuple[float, float], oversampling_factor: int, roi: ndarray) -> np.ndarray

Recenter over the target position and oversample the target area.

Target area is recentered over the target position. Then it is cropped to the size given by roi and finally oversampled by the given factor.

Parameters:

Name Type Description Default
target_area ndarray

input data with shape (N, M)

 required
target_pos_real tuple[float, float]

position of the signal peak in pixels as fractional index

 required
oversampling_factor int

oversampling factor

 required
roi ndarray

crop size (n, m)

 required

Returns:

Type Description
ndarray

oversampled image, with shape (n * oversampling_factor, m * oversampling_factor)

Raises:

Type Description
TargetAreaRecenteringError

if target position is invalid

compute_roi

Python
compute_roi(data_shape: tuple[int, int], oversampling_factor: int) -> np.ndarray

Computing the region of interest along range and azimuth.

Parameters:

Name Type Description Default
data_shape tuple[int, int]

shape of the target area

 required
oversampling_factor int

oversampling factor

 required

Returns:

Type Description
ndarray

region of interest, range_px[0] and azimuth_px[1]

generate_irf_axis

Python
generate_irf_axis(stop: float, offset: float, scaling: float) -> np.ndarray

Generate IRF axis from input parameters.

Parameters:

Name Type Description Default
stop float

axis stop

 required
offset float

axis offset

 required
scaling float

axis scaling

 required

Returns:

Type Description
ndarray

irf axis array

extract_target_area

Python
extract_target_area(channel_data: ChannelData, azimuth_range_coordinates: SARCoordinates, ale_limits: tuple[float, float] | None = None, initial_crop: tuple[int, int] = (33, 33), final_crop: tuple[int, int] = (128, 128), ovrs_factor: int = 5) -> tuple[np.ndarray | None, np.ndarray | None, np.ndarray | None, np.ndarray | None]

Extract a portion of the swath around target area from input product.

Parameters:

Name Type Description Default
channel_data ChannelData

product channel data instance

 required
azimuth_range_coordinates SARCoordinates

azimuth and range coordinates SARCoordinates dataclass

 required
ale_limits tuple[float, float] | None

absolute localization error limits, by default None

 None
initial_crop tuple[int, int]

first step roi boundaries (range, azimuth), by default (33, 33)

 (33, 33)
final_crop tuple[int, int]

final step roi boundaries (range, azimuth), by default (128, 128)

 (128, 128)
ovrs_factor int

oversampling factor (arbitrarily chosen)

 5

Returns:

Type Description
ndarray | None

cropped target area centered on interpolated peak coordinates
ndarray | None

peak coordinates
ndarray | None

nominal target reference coordinates in this frame [row, col]
ndarray | None

main lobe peak coordinates (rng[0], az[1]) in pixels referred to the whole swath

Utilities

Definition of Point Target Analysis configuration

Classes

IRFParameters dataclass

IRF analysis detailed setup parameters

Attributes

peak_finding_roi_size class-attribute instance-attribute
Python
peak_finding_roi_size: tuple[int, int] = (33, 33)
analysis_roi_size class-attribute instance-attribute
Python
analysis_roi_size: tuple[int, int] = (128, 128)
oversampling_factor class-attribute instance-attribute
Python
oversampling_factor: int = 16
zero_doppler_abs_squint_threshold_deg class-attribute instance-attribute
Python
zero_doppler_abs_squint_threshold_deg: float = 1.0
masking_method class-attribute instance-attribute
Python
masking_method: MaskingMethod = MaskingMethod.PEAK

Methods:

__init__
Python
__init__(peak_finding_roi_size: tuple[int, int] = (33, 33), analysis_roi_size: tuple[int, int] = (128, 128), oversampling_factor: int = 16, zero_doppler_abs_squint_threshold_deg: float = 1.0, masking_method: MaskingMethod = MaskingMethod.PEAK) -> None
from_dict classmethod
Python
from_dict(arg: dict) -> IRFParameters

Creating a IRFParameters object by conversion from a dictionary.

Args: arg (dict): dictionary with keys equal to the IRFParameters ones

Returns: IRFParameters: IRFParameters object

RCSParameters dataclass

RCS analysis detailed setup parameters

Attributes

interpolation_factor class-attribute instance-attribute
Python
interpolation_factor: int = 8
roi_dimension class-attribute instance-attribute
Python
roi_dimension: int = 128
calibration_factor class-attribute instance-attribute
Python
calibration_factor: float = 1.0
resampling_factor class-attribute instance-attribute
Python
resampling_factor: float = 1.0

Methods:

__init__
Python
__init__(interpolation_factor: int = 8, roi_dimension: int = 128, calibration_factor: float = 1.0, resampling_factor: float = 1.0) -> None
from_dict classmethod
Python
from_dict(arg: dict) -> RCSParameters

Creating a RCSParameters object by conversion from a dictionary.

Args: arg (dict): dictionary with keys equal to the RCSParameters ones

Returns: RCSParameters: RCSParameters object

PointTargetAnalysisConfig dataclass

Dataclass to manage, enable and customize different part of the Point Target Analysis procedure

Attributes

perform_irf class-attribute instance-attribute
Python
perform_irf: bool = True
perform_rcs class-attribute instance-attribute
Python
perform_rcs: bool = True
evaluate_pslr class-attribute instance-attribute
Python
evaluate_pslr: bool = True
evaluate_islr class-attribute instance-attribute
Python
evaluate_islr: bool = True
evaluate_sslr class-attribute instance-attribute
Python
evaluate_sslr: bool = True
evaluate_localization class-attribute instance-attribute
Python
evaluate_localization: bool = True
generate_static_graphs class-attribute instance-attribute
Python
generate_static_graphs: bool = True
check_targets_in_scene class-attribute instance-attribute
Python
check_targets_in_scene: bool = True
ale_limits class-attribute instance-attribute
Python
ale_limits: tuple[float, float] | None = None
irf_parameters class-attribute instance-attribute
Python
irf_parameters: IRFParameters = field(default_factory=IRFParameters)
rcs_parameters class-attribute instance-attribute
Python
rcs_parameters: RCSParameters = field(default_factory=RCSParameters)

Methods:

__init__
Python
__init__(perform_irf: bool = True, perform_rcs: bool = True, evaluate_pslr: bool = True, evaluate_islr: bool = True, evaluate_sslr: bool = True, evaluate_localization: bool = True, generate_static_graphs: bool = True, check_targets_in_scene: bool = True, ale_limits: tuple[float, float] | None = None, irf_parameters: IRFParameters = IRFParameters(), rcs_parameters: RCSParameters = RCSParameters()) -> None
from_dict classmethod
Python
from_dict(arg: dict) -> PointTargetAnalysisConfig

Creating a PointTargetAnalysisConfig object by conversion from a dictionary.

Args: arg (dict): dictionary with keys equal to the PointTargetAnalysisConfig ones

Returns: PointTargetAnalysisConfig: PointTargetAnalysisConfig object

Functions:

Definition of Point Target Analysis specific dataclasses

Attributes

Classes

IRFComputedParameters dataclass

Attributes

range_pslr class-attribute instance-attribute
Python
range_pslr: float = np.nan
azimuth_pslr class-attribute instance-attribute
Python
azimuth_pslr: float = np.nan
pslr_2d class-attribute instance-attribute
Python
pslr_2d: float = np.nan
range_islr class-attribute instance-attribute
Python
range_islr: float = np.nan
azimuth_islr class-attribute instance-attribute
Python
azimuth_islr: float = np.nan
islr_2d class-attribute instance-attribute
Python
islr_2d: float = np.nan
range_sslr class-attribute instance-attribute
Python
range_sslr: float = np.nan
azimuth_sslr class-attribute instance-attribute
Python
azimuth_sslr: float = np.nan
sslr_2d class-attribute instance-attribute
Python
sslr_2d: float = np.nan

Methods:

__init__
Python
__init__(range_pslr: float = np.nan, azimuth_pslr: float = np.nan, pslr_2d: float = np.nan, range_islr: float = np.nan, azimuth_islr: float = np.nan, islr_2d: float = np.nan, range_sslr: float = np.nan, azimuth_sslr: float = np.nan, sslr_2d: float = np.nan) -> None

IRFDataOutput dataclass

Input Response dataclass containing all relevant information computed in the Point Target IRF analysis class.

Attributes

range_resolution class-attribute instance-attribute
Python
range_resolution: float = np.nan
azimuth_resolution class-attribute instance-attribute
Python
azimuth_resolution: float = np.nan
ground_range_resolution class-attribute instance-attribute
Python
ground_range_resolution: float = np.nan
range_pslr class-attribute instance-attribute
Python
range_pslr: float = np.nan
azimuth_pslr class-attribute instance-attribute
Python
azimuth_pslr: float = np.nan
pslr_2d class-attribute instance-attribute
Python
pslr_2d: float = np.nan
range_islr class-attribute instance-attribute
Python
range_islr: float = np.nan
azimuth_islr class-attribute instance-attribute
Python
azimuth_islr: float = np.nan
islr_2d class-attribute instance-attribute
Python
islr_2d: float = np.nan
range_sslr class-attribute instance-attribute
Python
range_sslr: float = np.nan
azimuth_sslr class-attribute instance-attribute
Python
azimuth_sslr: float = np.nan
sslr_2d class-attribute instance-attribute
Python
sslr_2d: float = np.nan
slant_range_localization_error class-attribute instance-attribute
Python
slant_range_localization_error: float = np.nan
azimuth_localization_error class-attribute instance-attribute
Python
azimuth_localization_error: float = np.nan
ground_range_localization_error class-attribute instance-attribute
Python
ground_range_localization_error: float = np.nan

Methods:

__init__
Python
__init__(range_resolution: float = np.nan, azimuth_resolution: float = np.nan, ground_range_resolution: float = np.nan, range_pslr: float = np.nan, azimuth_pslr: float = np.nan, pslr_2d: float = np.nan, range_islr: float = np.nan, azimuth_islr: float = np.nan, islr_2d: float = np.nan, range_sslr: float = np.nan, azimuth_sslr: float = np.nan, sslr_2d: float = np.nan, slant_range_localization_error: float = np.nan, azimuth_localization_error: float = np.nan, ground_range_localization_error: float = np.nan) -> None
from_dict staticmethod
Python
from_dict(arg: dict) -> 'IRFDataOutput'

Creating a IRFDataOutput object by conversion from a dictionary.

Args: arg (dict): dictionary with keys equal to the IRFDataOutput ones

Returns: IRFDataOutput: IRFDataOutput object

__str__
Python
__str__() -> str
__sub__
Python
__sub__(other: 'IRFDataOutput') -> 'IRFDataOutput'

Subtraction operation override.

Parameters:

Name Type Description Default
other IRFDataOutput

object to be subtracted to self, actually another IRFDataOutput object

 required

Returns:

Type Description
IRFDataOutput

IRFDataOutput dataclass containing the subtraction between the two

RCSDataOutput dataclass

Dataclass to collect the output of RCS analysis

Attributes

rcs class-attribute instance-attribute
Python
rcs: float = np.nan
rcs_error class-attribute instance-attribute
Python
rcs_error: float = np.nan
peak_phase_error class-attribute instance-attribute
Python
peak_phase_error: float = np.nan
peak_value_complex class-attribute instance-attribute
Python
peak_value_complex: complex = np.nan
clutter class-attribute instance-attribute
Python
clutter: float = np.nan
scr class-attribute instance-attribute
Python
scr: float = np.nan

Methods:

__init__
Python
__init__(rcs: float = np.nan, rcs_error: float = np.nan, peak_phase_error: float = np.nan, peak_value_complex: complex = np.nan, clutter: float = np.nan, scr: float = np.nan) -> None

GenericInfoOutput dataclass

Dataclass to collect generic output for the whole Point Target Analysis

Attributes

swath class-attribute instance-attribute
Python
swath: str | None = None
burst class-attribute instance-attribute
Python
burst: int | None = None
product_type class-attribute instance-attribute
Python
product_type: str | None = None
polarization class-attribute instance-attribute
Python
polarization: str | None = None
acquisition_mode class-attribute instance-attribute
Python
acquisition_mode: str | None = None
acquisition_start_time class-attribute instance-attribute
Python
acquisition_start_time: datetime | None = None
incidence_angle class-attribute instance-attribute
Python
incidence_angle: float | None = None
squint_angle class-attribute instance-attribute
Python
squint_angle: float | None = None
range_position class-attribute instance-attribute
Python
range_position: float | None = None
azimuth_position class-attribute instance-attribute
Python
azimuth_position: float | None = None

Methods:

__init__
Python
__init__(swath: str | None = None, burst: int | None = None, product_type: str | None = None, polarization: str | None = None, acquisition_mode: str | None = None, acquisition_start_time: datetime | None = None, incidence_angle: float | None = None, squint_angle: float | None = None, range_position: float | None = None, azimuth_position: float | None = None) -> None

PTAdditionalInfo dataclass

Additional info for other needs

Attributes

orbit_direction class-attribute instance-attribute
Python
orbit_direction: SAROrbitDirection | None = None
peak_azimuth_time class-attribute instance-attribute
Python
peak_azimuth_time: PreciseDateTime | None = None
peak_azimuth_from_burst_start class-attribute instance-attribute
Python
peak_azimuth_from_burst_start: float | None = None
peak_range_time class-attribute instance-attribute
Python
peak_range_time: float | None = None
look_angle class-attribute instance-attribute
Python
look_angle: float | None = None
ground_velocity class-attribute instance-attribute
Python
ground_velocity: float | None = None
doppler_rate_theoretical class-attribute instance-attribute
Python
doppler_rate_theoretical: float | None = None
doppler_rate_real class-attribute instance-attribute
Python
doppler_rate_real: float | None = None
doppler_frequency class-attribute instance-attribute
Python
doppler_frequency: float | None = None
steering_doppler_frequency class-attribute instance-attribute
Python
steering_doppler_frequency: float | None = None

Methods:

__init__
Python
__init__(orbit_direction: SAROrbitDirection | None = None, peak_azimuth_time: PreciseDateTime | None = None, peak_azimuth_from_burst_start: float | None = None, peak_range_time: float | None = None, look_angle: float | None = None, ground_velocity: float | None = None, doppler_rate_theoretical: float | None = None, doppler_rate_real: float | None = None, doppler_frequency: float | None = None, steering_doppler_frequency: float | None = None) -> None

PointTargetAnalysisOutput dataclass

Dataclass to collect output for the whole Point Target Analysis

Attributes

target class-attribute instance-attribute
Python
target: int | None = None
channel class-attribute instance-attribute
Python
channel: str | None = None
product_name class-attribute instance-attribute
Python
product_name: str | None = None
sensor_name class-attribute instance-attribute
Python
sensor_name: str | None = None
info class-attribute instance-attribute
Python
info: GenericInfoOutput = field(default_factory=GenericInfoOutput)
irf class-attribute instance-attribute
Python
irf: IRFDataOutput = field(default_factory=IRFDataOutput)
rcs class-attribute instance-attribute
Python
rcs: RCSDataOutput = field(default_factory=RCSDataOutput)
additional_info class-attribute instance-attribute
Python
additional_info: PTAdditionalInfo = field(default_factory=PTAdditionalInfo)

Methods:

__init__
Python
__init__(target: int | None = None, channel: str | None = None, product_name: str | None = None, sensor_name: str | None = None, info: GenericInfoOutput = GenericInfoOutput(), irf: IRFDataOutput = IRFDataOutput(), rcs: RCSDataOutput = RCSDataOutput(), additional_info: PTAdditionalInfo = PTAdditionalInfo()) -> None

IRFGraphDataOutput dataclass

Dataclass needed to store data for generating graphical output for IRF

Attributes

image class-attribute instance-attribute
Python
image: ndarray | None = None
rng_axis class-attribute instance-attribute
Python
rng_axis: NDArray[floating] | None = None
rng_profile class-attribute instance-attribute
Python
rng_profile: NDArray[floating] | None = None
rng_resolution class-attribute instance-attribute
Python
rng_resolution: float | None = None
rng_step_distance class-attribute instance-attribute
Python
rng_step_distance: float | None = None
az_axis class-attribute instance-attribute
Python
az_axis: ndarray | None = None
az_profile class-attribute instance-attribute
Python
az_profile: NDArray[floating] | None = None
az_resolution class-attribute instance-attribute
Python
az_resolution: float | None = None
az_step_distance class-attribute instance-attribute
Python
az_step_distance: float | None = None
side_lobes_directions class-attribute instance-attribute
Python
side_lobes_directions: SideLobesDirections | None = None

Methods:

__init__
Python
__init__(image: ndarray | None = None, rng_axis: NDArray[floating] | None = None, rng_profile: NDArray[floating] | None = None, rng_resolution: float | None = None, rng_step_distance: float | None = None, az_axis: ndarray | None = None, az_profile: NDArray[floating] | None = None, az_resolution: float | None = None, az_step_distance: float | None = None, side_lobes_directions: SideLobesDirections | None = None) -> None

RCSGraphDataOutput dataclass

Dataclass needed to store data for generating graphical output for RCS

Attributes

image class-attribute instance-attribute
Python
image: ndarray | None = None
data_type class-attribute instance-attribute
Python
data_type: str | None = None
roi_background class-attribute instance-attribute
Python
roi_background: list | None = None
roi_peak class-attribute instance-attribute
Python
roi_peak: list | None = None
rng_step_distance class-attribute instance-attribute
Python
rng_step_distance: float | None = None
az_step_distance class-attribute instance-attribute
Python
az_step_distance: float | None = None
roi_size class-attribute instance-attribute
Python
roi_size: NDArray[floating] | None = None
interp_factor class-attribute instance-attribute
Python
interp_factor: int | None = None
rcs_lin class-attribute instance-attribute
Python
rcs_lin: float | None = None
rcs_db class-attribute instance-attribute
Python
rcs_db: float | None = None

Methods:

__init__
Python
__init__(image: ndarray | None = None, data_type: str | None = None, roi_background: list | None = None, roi_peak: list | None = None, rng_step_distance: float | None = None, az_step_distance: float | None = None, roi_size: NDArray[floating] | None = None, interp_factor: int | None = None, rcs_lin: float | None = None, rcs_db: float | None = None) -> None

PointTargetGraphicalData dataclass

Dataclass to collect data for graphical output of Point Target Analysis

Attributes

target class-attribute instance-attribute
Python
target: int | None = None
channel class-attribute instance-attribute
Python
channel: str | None = None
swath class-attribute instance-attribute
Python
swath: str | None = None
burst class-attribute instance-attribute
Python
burst: int | None = None
polarization class-attribute instance-attribute
Python
polarization: SARPolarization | None = None
irf class-attribute instance-attribute
Python
irf: IRFGraphDataOutput | None = None
rcs class-attribute instance-attribute
Python
rcs: RCSGraphDataOutput | None = None

Methods:

__init__
Python
__init__(target: int | None = None, channel: str | None = None, swath: str | None = None, burst: int | None = None, polarization: SARPolarization | None = None, irf: IRFGraphDataOutput | None = None, rcs: RCSGraphDataOutput | None = None) -> None

PTAGraphsInfo dataclass

Simple Info for Graphs labelling

Attributes

channel instance-attribute
Python
channel: str
swath instance-attribute
Python
swath: str
polarization instance-attribute
Python
polarization: str
burst instance-attribute
Python
burst: str
target instance-attribute
Python
target: str

Methods:

__init__
Python
__init__(channel: str, swath: str, polarization: str, burst: str, target: str) -> None

Definition of custom errors for troubleshooting of Point Target Analysis

Classes

PointTargetComputationError

Bases: RuntimeError

Error raised while computing Point Target Analysis