# mmwave.dsp.angle_estimation¶

mmwave.dsp.angle_estimation.azimuth_processing(radar_cube, det_obj_2d, config, window_type_2d=None)

Calculate the X/Y coordinates for all detected objects.

The following procedures will be performed in this function:

1. Filter radarCube based on the range indices from detObj2D and optional clutter removal.
2. Re-do windowing and 2D FFT, select associated doppler indices to form the azimuth input.
3. Doppler compensation on the virtual antennas related to tx2. Save optional copy for near field compensation and velocity disambiguation.
4. Perform azimuth FFT.
5. Optional near field correction and velocity disambiguation. Currently mutual exclusive.
6. Magnitude squared.
7. Calculate X/Y coordinates.
Parameters: radar_cube – (numChirpsPerFrame, numRxAntennas, numRangeBins). Because of the space limitation, TI Demo starts again from the 1D FFT, recalculate the 2D FFT on the selected range bins and pick the associated doppler bins for the azimuth FFT. det_obj_2d – (numDetObj, 3) config – [TBD] window_type_2d – windowing function for the 2D FFT. Default is None. (numDetObj, 5). Copy of detObj2D but with populated X/Y coordinates. azimuthOut
mmwave.dsp.angle_estimation.aoa_bartlett(steering_vec, sig_in, axis)

Perform AOA estimation using Bartlett Beamforming on a given input signal (sig_in). Make sure to specify the correct axis in (axis) to ensure correct matrix multiplication. The power spectrum is calculated using the following equation:

$P_{ca} (\theta) = a^{H}(\theta) R_{xx}^{-1} a(\theta)$

This steers the beam using the steering vector as weights:

$w_{ca} (\theta) = a(\theta)$
Parameters: steering_vec (ndarray) – A 2D-array of size (numTheta, num_ant) generated from gen_steering_vec sig_in (ndarray) – Either a 2D-array or 3D-array of size (num_ant, numChirps) or (numChirps, num_vrx, num_adc_samples) respectively, containing ADC sample data sliced as described axis (int) – Specifies the axis where the Vrx data in contained. A 3D-array of size (numChirps, numThetas, numSamples) doa_spectrum (ndarray)

Example

>>> # In this example, dataIn is the input data organized as numFrames by RDC
>>> frame = 0
>>> dataIn = np.random.rand((num_frames, num_chirps, num_vrx, num_adc_samples))
>>> aoa_bartlett(steering_vec,dataIn[frame],axis=1)

mmwave.dsp.angle_estimation.aoa_capon(x, steering_vector, magnitude=False)

Perform AOA estimation using Capon (MVDR) Beamforming on a rx by chirp slice

Calculate the aoa spectrum via capon beamforming method using one full frame as input. This should be performed for each range bin to achieve AOA estimation for a full frame This function will calculate both the angle spectrum and corresponding Capon weights using the equations prescribed below.

\begin{align}\begin{aligned}P_{ca} (\theta) = \frac{1}{a^{H}(\theta) R_{xx}^{-1} a(\theta)}\\w_{ca} (\theta) = \frac{R_{xx}^{-1} a(\theta)}{a^{H}(\theta) R_{xx}^{-1} a(\theta)}\end{aligned}\end{align}
Parameters: x (ndarray) – Output of the 1d range fft with shape (num_ant, numChirps) steering_vector (ndarray) – A 2D-array of size (numTheta, num_ant) generated from gen_steering_vec magnitude (bool) – Azimuth theta bins should return complex data (False) or magnitude data (True). Default=False ValueError – steering_vector and or x are not the correct shape A list containing numVec and steeringVectors den (ndarray: A 1D-Array of size (numTheta) containing azimuth angle estimations for the given range weights (ndarray): A 1D-Array of size (num_ant) containing the Capon weights for the given input data

Example

>>> # In this example, dataIn is the input data organized as numFrames by RDC
>>> Frame = 0
>>> dataIn = np.random.rand((num_frames, num_chirps, num_vrx, num_adc_samples))
>>> for i in range(256):
>>>     scan_aoa_capon[i,:], _ = dss.aoa_capon(dataIn[Frame,:,:,i].T, steering_vector, magnitude=True)

mmwave.dsp.angle_estimation.cov_matrix(x)
Calculates the spatial covariance matrix (Rxx) for a given set of input data (x=inputData).
Assumes rows denote Vrx axis.
Parameters: x (ndarray) – A 2D-Array with shape (rx, adc_samples) slice of the output of the 1D range fft A 2D-Array with shape (rx, rx) Rxx (ndarray)
mmwave.dsp.angle_estimation.forward_backward_avg(Rxx)

Performs forward backward averaging on the given input square matrix

Parameters: Rxx (ndarray) – A 2D-Array square matrix containing the covariance matrix for the given input data The 2D-Array square matrix containing the forward backward averaged covariance matrix R_fb (ndarray)
Wrapper function to perform scipy.signal’s prescribed peak search algorithm
Tested Runtime: 45 µs ± 2.61 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Parameters: doa_spectrum (ndarray) – A 1D-Array of size (numTheta, 1) containing the theta spectrum at a given range bin peak_threshold_weight (float) – A float specifying the desired peak declaration threshold weight to be applied The number of max points found by the algorithm peaks (list): List of indexes where peaks are located total_power (float): Total power in the current spectrum slice num_max (int)
mmwave.dsp.angle_estimation.peak_search_full(doa_spectrum, gamma=1.2, peak_threshold_weight=0.251188643150958)

Perform TI prescribed peak search algorithm Tested Runtime: 147 µs ± 4.27 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Parameters: doa_spectrum (ndarray) – A 1D-Array of size (numTheta, 1) containing the theta spectrum at a given range bin gamma (float) – A float specifying the maximum/minimum wiggle necessary to qualify as a peak peak_threshold_weight (float) – A float specifying the desired peak declaration threshold weight to be applied The number of max points found by the algorithm ang_est (list): List of indexes where the peaks are located num_max (int)
mmwave.dsp.angle_estimation.peak_search_full_variance(doa_spectrum, steering_vec_size, sidelobe_level=0.251188643150958, gamma=1.2)

Performs peak search (TI’s full search) will retaining details about each peak including each peak’s width, location, and value.

Parameters: doa_spectrum (ndarray) – a 1D numpy array containing the power spectrum generated via some aoa method (naive, or capon) (bartlett,) – steering_vec_size (int) – Size of the steering vector in terms of number of theta bins sidelobe_level (float) – A low value threshold used to avoid sidelobe detections as peaks gamma (float) – Weight to determine when a peak will pass as a true peak A 1D numpy array of custom data types with length numberOfPeaksDetected. Each detected peak is organized as [peak_location, peak_value, peak_width] total_power (float): The total power of the spectrum. Used for variance calculations peak_data (ndarray)
mmwave.dsp.angle_estimation.variance_estimation(num_max, est_resolution, peak_data, total_power, width_adjust_3d_b=2.5, input_snr=10000)
This function will calculate an estimated variance value for each detected peak. This should
be run after running peak_search_full_variance
Parameters: num_max (int) – The number of detected peaks est_resolution (float) – The desired resolution in terms of theta peak_data (ndarray) – A numpy array of dictionaries, where each dictionary is of the form: {“peakLoc”: , “peakVal”: , “peakWid”: } total_power (float) – The total power of the spectrum width_adjust_3d_b (float) – Constant to adjust the gamma bandwidth to 3dB level input_snr (int) – the linear snr for the input signal samples A 1D array of variances (of the peaks). The order of the peaks is preserved from peak_data est_var (ndarray)
mmwave.dsp.angle_estimation.gen_steering_vec(ang_est_range, ang_est_resolution, num_ant)

Generate a steering vector for AOA estimation given the theta range, theta resolution, and number of antennas

Defines a method for generating steering vector data input –Python optimized Matrix format The generated steering vector will span from -angEstRange to angEstRange with increments of ang_est_resolution The generated steering vector should be used for all further AOA estimations (bartlett/capon)

Parameters: ang_est_range (int) – The desired span of thetas for the angle spectrum. ang_est_resolution (float) – The desired resolution in terms of theta num_ant (int) – The number of Vrx antenna signals captured in the RDC Number of vectors generated (integer divide angEstRange/ang_est_resolution) steering_vectors (ndarray): The generated 2D-array steering vector of size (num_vec,num_ant) num_vec (int)

Example

>>> #This will generate a numpy array containing the steering vector with
>>> #angular span from -90 to 90 in increments of 1 degree for a 4 Vrx platform
>>> _, steering_vec = gen_steering_vec(90,1,4)

mmwave.dsp.angle_estimation.aoa_estimation_bf_one_point(num_ant, sig_in, steering_vec)

Calculates the total power of the given spectrum

Parameters: num_ant (int) – The number of virtual antennas (Vrx) being used sig_in (ndarray) – A 2D-array of size (num_ant, numChirps) containing ADC sample data sliced for used Vrx steering_vec (ndarray) – A 2D-array of size (numTheta, num_ant) generated from gen_steering_vec The total power of the given input spectrum out_value (complex)
mmwave.dsp.angle_estimation.aoa_est_bf_single_peak_det(sig_in, steering_vec)
Beamforming Estimate Angle of Arrival for single peak (single peak should be known a priori)
Function call does not include variance calculations Function does not generate a spectrum. Rather, it only returns the array index (theta) to the highest peak
Parameters: sig_in (ndarray) – A 2D-array of size (num_ant, numChirps) containing ADC sample data sliced as described steering_vec (ndarray) – A generated 2D-array steering vector of size (numVec,num_ant) Index of the theta spectrum at a given range bin that contains the max peak max_index (int)
mmwave.dsp.angle_estimation.aoa_est_bf_single_peak(num_ant, noise, est_resolution, sig_in, steering_vec_size, steering_vec)
Beamforming Estimate Angle of Arrival for single peak (single peak should be known a priori)
Function call includes variance calculations Function does generate a spectrum.
Parameters: num_ant (int) – The number of virtual receivers in the current radar setup noise (float) – Input noise figure est_resolution (float) – Desired theta spectrum resolution used when generating steering_vec sig_in (ndarray) – A 2D-array of size (num_ant, numChirps) containing ADC sample data sliced as described steering_vec_size (int) – Length of the steering vector array steering_vec (ndarray) – A generated 2D-array steering vector of size (numVec,num_ant) The estimated variance of the doa_spectrum max_index (int): Index of the theta spectrum at a given range bin that contains the max peak doa_spectrum (ndarray): A 1D-Array of size (numTheta, 1) containing the theta spectrum at a given range bin est_var (float)
mmwave.dsp.angle_estimation.aoa_est_bf_multi_peak_det(gamma, sidelobe_level, sig_in, steering_vec, steering_vec_size, ang_est, search=False)

Use Bartlett beamforming to estimate AOA for multi peak situation (a priori), no variance calculation

Parameters: gamma (float) – Weight to determine when a peak will pass as a true peak sidelobe_level (float) – A low value threshold used to avoid sidelobe detections as peaks sig_in (ndarray) – A 2D-array of size (num_ant, numChirps) containing ADC sample data sliced as described steering_vec (ndarray) – A generated 2D-array steering vector of size (numVec,num_ant) steering_vec_size (int) – Length of the steering vector array ang_est (ndarray) – An empty 1D numpy array that gets populated with max indexes search (bool) – Flag that determines whether search is done to find max points The number of max points found across the theta bins at this particular range bin doa_spectrum (ndarray): A 1D-Array of size (numTheta, 1) containing the theta spectrum at a given range bin num_max (int)
mmwave.dsp.angle_estimation.aoa_est_bf_multi_peak(gamma, sidelobe_level, width_adjust_3d_b, input_snr, est_resolution, sig_in, steering_vec, steering_vec_size, peak_data, ang_est)

This function performs all sections of the angle of arrival process in one function.

1. Performs bartlett beamforming
2. Performs multi-peak search
3. Calculates an estimated variance
Parameters: gamma (float) – Weight to determine when a peak will pass as a true peak sidelobe_level (float) – A low value threshold used to avoid sidelobe detections as peaks width_adjust_3d_b (float) – Constant to adjust gamma bandwidth to 3dB bandwidth input_snr (float) – Input data SNR value est_resolution (float) – User defined target resolution sig_in (ndarray) – A 2D-array of size (num_ant, numChirps) containing ADC sample data sliced as described steering_vec (ndarray) – A generated 2D-array steering vector of size (numVec,num_ant) steering_vec_size (int) – Length of the steering vector array peak_data (ndarray) – A 2D ndarray with custom data-type that contains information on each detected point ang_est (ndarray) – An empty 1D numpy array that gets populated with max indexes Tuple [ndarray, ndarray] num_max (int): The number of max values detected by search algorithm est_var (ndarray): The estimated variance of this range of thetas at this range bin
mmwave.dsp.angle_estimation.naive_xyz(virtual_ant, num_tx=3, num_rx=4, fft_size=64)

Estimate the phase introduced from the elevation of the elevation antennas

Parameters: virtual_ant – Signal received by the rx antennas, shape = [#angleBins, #detectedObjs], zero-pad #virtualAnts to #angleBins num_tx – Number of transmitter antennas used num_rx – Number of receiver antennas used fft_size – Size of the fft performed on the signals Estimated x axis coordinate in meters (m) y_vector (float): Estimated y axis coordinate in meters (m) z_vector (float): Estimated z axis coordinate in meters (m) x_vector (float)
mmwave.dsp.angle_estimation.beamforming_naive_mixed_xyz(azimuth_input, input_ranges, range_resolution, method='Capon', num_vrx=12, est_range=90, est_resolution=1)

This function estimates the XYZ location of a series of input detections by performing beamforming on the azimuth axis and naive AOA on the vertical axis.

TI xWR1843 virtual antenna map Row 1 8 9 10 11 Row 2 0 1 2 3 4 5 6 7

phi (ndarray): theta (ndarray): ranges (ndarray): xyz_vec (ndarray):

Parameters: azimuth_input (ndarray) – Must be a numpy array of shape (numDetections, numVrx) input_ranges (ndarray) – Numpy array containing the rangeBins that have detections (will determine x, y, z for detection) (each) – range_resolution (float) – The range_resolution in meters per rangeBin for rangeBin->meter conversion method (string) – Determines which beamforming method to use for azimuth aoa estimation. num_vrx (int) – Number of virtual antennas in the radar platform. Default set to 12 for 1843 est_range (int) – The desired span of thetas for the angle spectrum. Used for gen_steering_vec est_resolution (float) – The desired angular resolution for gen_steering_vec ValueError – If method is not one of two AOA implementations (‘Capon’, ‘Bartlett’) ValueError – azimuthInput’s second axis should have same shape as the number of Vrx A numpy array of shape (numDetections, ) where each element represents the elevation angle in degrees A numpy array of shape (numDetections, ) where each element represents the azimuth in degrees A numpy array of shape (numDetections, ) where each element represents the polar range in rangeBins A numpy array of shape (3, numDetections) and format: [x, y, z] where x, y, z are 1D arrays. x, y, z should be in meters tuple [ndarray, ndarray, ndarray, ndarray, list]