Angle estimation

This page covers the angle stage of witwin.radar.processing. All directions are in the array's local frame.

from witwin.radar.processing import (ArrayGeometry, BeamCube, beam_cube, conventional_steering, fft2_aoa,
                                     music_image, music_spectrum, mvdr_weights, phase_comparison_aoa,
                                     tdm_compensate)

The virtual array is ordered TX-major: pair p belongs to transmitter p // num_rx and receiver p % num_rx. A TDM-MIMO virtual element sits at the sum of its transmitter and receiver offsets. The offsets are the tx and rx positions of the radar, in its local frame: x to the right, y up, boresight along -z. For a planar array in the x-y plane, only the x and y parts of a direction change the steering phase.

ArrayGeometry#

class ArrayGeometry(element_positions_m, num_tx, num_rx, element_spacing_m, wavelength_m, phase_sign,
                    tx_loc_half_wavelength, rx_loc_half_wavelength)

Positions of every virtual element and the sign of its phase. Get one with frame.array().

ArrayGeometry.from_axes#

ArrayGeometry.from_axes(axes) -> ArrayGeometry

Build from a ProcessingAxes. frame.array() calls this.

ArrayGeometry.from_offsets#

ArrayGeometry.from_offsets(tx_loc, rx_loc, *, element_spacing_m, wavelength_m, phase_sign=-1, device='cpu') -> ArrayGeometry

Build from two element-offset grids in units of element_spacing_m. Use it for an array that is not half-wavelength spaced.

conventional_steering#

conventional_steering(array, directions, *, normalize=True, dtype=torch.complex64) -> torch.Tensor

Phase-shift weights [P, *beam] for a grid of look directions.

mvdr_weights#

mvdr_weights(covariance, steering, *, diagonal_loading) -> torch.Tensor

Minimum-variance distortionless-response weights w = R^-1 a / (a^H R^-1 a), [..., P, B]. They satisfy the same w^H a = 1 constraint as conventional_steering, so the two are interchangeable in beam_cube.

beam_cube#

beam_cube(rd, steering, *, directions) -> BeamCube

Apply beamforming weights to a range-Doppler map: y[b] = sum_p conj(w[p, b]) · x[p].

Returns BeamCube with data [*beam, D, R], axes, directions, and the range_axis and doppler_axis properties.

import torch
 
az = torch.linspace(-0.8, 0.8, 61, device=radar.device)
directions = torch.stack((torch.sin(az), torch.zeros_like(az), -torch.cos(az)), dim=-1)   # local -z is boresight
weights = conventional_steering(frame.array(), directions)
beams = beam_cube(frame.range_doppler(), weights, directions=directions)
print(beams.data.shape)   # [61, doppler, range]

tdm_compensate#

tdm_compensate(aoa_input, velocities, array, axes) -> torch.Tensor

Remove the phase a moving target writes across TDM transmitters, which are sampled one chirp apart. Apply it before an angle estimate on a moving target.

Returns a tensor of the same shape and dtype.

phase_comparison_aoa#

phase_comparison_aoa(virtual_ant, array, *, fft_size=64) -> torch.Tensor

Direction cosines [3, N] from two one-dimensional FFTs: azimuth from the first 2 · num_rx elements, elevation from the phase difference to the sub-aperture 2 · num_rx elements later. On a half-wavelength array, x = sin(azimuth). Elevation is coarse: the correction uses the azimuth peak bin, not the continuous azimuth.

fft2_aoa#

fft2_aoa(virtual_ant, array, *, fft_size=64) -> torch.Tensor

Direction cosines [3, N] from one zero-padded two-dimensional FFT over a planar virtual array of num_tx // 2 by 2 · num_rx elements. Reads both angles off one grid, so elevation is more accurate than with phase_comparison_aoa.

Raises ValueError for an array with fewer than four transmitters.

music_spectrum#

music_spectrum(angle_data, array, *, elevation_rad, azimuth_rad, num_signals=7, spatial_smooth=3) -> torch.Tensor

MUSIC pseudo-spectrum [B, len(elevation_rad), len(azimuth_rad)] from [B, M, N, T] data: B range bins, an M by N planar array, T snapshots. Forward spatial smoothing averages the covariance over sub-arrays to decorrelate coherent multipath. Differentiable.

music_image#

music_image(profile, array, *, elevation_rad, azimuth_rad, range_bins, num_signals=7, spatial_smooth=3,
            num_snapshots=8) -> torch.Tensor

A MUSIC image [elevation, azimuth, bins] from a range profile. Differentiable.

See Resolve two targets with MUSIC for a complete example.

beam_cube, conventional_steering, mvdr_weights, tdm_compensate, music_spectrum and music_image are differentiable. phase_comparison_aoa and fft2_aoa pick peaks and refuse inputs that carry a gradient.