processing_code/utils/extract_pcd.py

"""Canonical 3-D radar point-cloud extraction used by ``processor --pcd``."""

import numpy as np

from utils.extract_radar_data import iiqq_to_iq, mimo

RANGE_FFT_SIZE = 256
DOPPLER_FFT_SIZE = 64
AZIMUTH_FFT_SIZE = 32
ELEVATION_FFT_SIZE = 8
RANGE_RES_M = 0.04375
CAMERA_POS_IN_RADAR_M = np.array([-0.08, 0.10, 0.05], dtype=np.float32)


def _hann(length: int) -> np.ndarray:
    return np.ones(length, dtype=np.float32) if length <= 2 else np.hanning(length).astype(np.float32)


def _fft(data: np.ndarray, axis: int, size: int | None = None, shift: bool = False) -> np.ndarray:
    shape = [1] * data.ndim
    shape[axis] = data.shape[axis]
    result = np.fft.fft(data * _hann(data.shape[axis]).reshape(shape), n=size, axis=axis)
    return np.fft.fftshift(result, axes=axis) if shift else result


def _training(values: np.ndarray, index: int, win: int, guard: int, cyclic: bool):
    left = np.arange(index - guard - win, index - guard)
    right = np.arange(index + guard + 1, index + guard + win + 1)
    if cyclic:
        return values[left % len(values)], values[right % len(values)]
    if left[0] < 0 or right[-1] >= len(values):
        return None, None
    return values[left], values[right]


def _cfar(values: np.ndarray, axis: int, mode: int, win: int, guard: int, noise_div: int, cyclic: bool, threshold_db: float) -> np.ndarray:
    data = np.moveaxis(values, axis, -1)
    detected = np.zeros_like(data, dtype=bool)
    scale = 10.0 ** (threshold_db / 20.0)
    for outer in np.ndindex(data.shape[:-1]):
        row = data[outer]
        for cut in range(len(row)):
            left, right = _training(row, cut, win, guard, cyclic)
            if left is None:
                continue
            left_sum, right_sum = float(left.sum()), float(right.sum())
            if mode == 0:
                noise = (left_sum + right_sum) / (2**noise_div)
            elif mode == 1:
                noise = max(left_sum, right_sum) / (2**noise_div)
            else:
                noise = min(left_sum, right_sum) / (2**noise_div)
            detected[outer + (cut,)] = row[cut] > noise * scale
    return np.moveaxis(detected, -1, axis)


def _local_maxima(values: np.ndarray) -> np.ndarray:
    rows, cols = values.shape
    output = np.zeros_like(values, dtype=bool)
    for row in range(rows):
        for col in range(cols):
            center = values[row, col]
            maximum = True
            for dr in (-1, 0, 1):
                for dc in (-1, 0, 1):
                    if dr == dc == 0:
                        continue
                    rr = (row + dr) % rows
                    cc = col + dc
                    if cc < 0 or cc >= cols:
                        continue
                    if values[rr, cc] >= center:
                        maximum = False
                        break
                if not maximum:
                    break
            output[row, col] = maximum
    return output


def _xyz(snapshot: np.ndarray, range_m: float) -> np.ndarray | None:
    window = _hann(2)[:, None] * _hann(8)[None, :]
    spectrum = np.fft.fftshift(np.fft.fft2(snapshot * window, s=(ELEVATION_FFT_SIZE, AZIMUTH_FFT_SIZE)), axes=(0, 1))
    elevation, azimuth = np.unravel_index(np.abs(spectrum).argmax(), spectrum.shape)
    ux = float(np.clip(2.0 * (azimuth - AZIMUTH_FFT_SIZE // 2) / AZIMUTH_FFT_SIZE, -1, 1))
    uy = float(np.clip(2.0 * (elevation - ELEVATION_FFT_SIZE // 2) / ELEVATION_FFT_SIZE, -1, 1))
    uz_sq = 1.0 - ux * ux - uy * uy
    if uz_sq <= 0:
        return None
    return np.array([range_m * ux, range_m * uy, range_m * np.sqrt(uz_sq)], dtype=np.float32)


def _nearest_per_ray(points: np.ndarray) -> np.ndarray:
    if len(points) == 0:
        return np.empty((0, 3), dtype=np.float32)
    ranges = np.linalg.norm(points, axis=1)
    valid = ranges > 1e-6
    points, ranges = points[valid], ranges[valid]
    chosen: dict[tuple[float, float, float], int] = {}
    for index, (direction, distance) in enumerate(zip(np.round(points / ranges[:, None], 6), ranges)):
        key = tuple(float(x) for x in direction)
        if key not in chosen or distance < ranges[chosen[key]]:
            chosen[key] = index
    return points[np.array(sorted(chosen.values()), dtype=np.int64)].astype(np.float32)


def extract_point_cloud_from_frame(iiqq_frame: np.ndarray) -> np.ndarray:
    """Return canonical ``(N, 3) float32`` camera-frame XYZ radar points."""
    virtual = mimo(iiqq_to_iq(iiqq_frame))
    range_fft = _fft(virtual, axis=-1, size=RANGE_FFT_SIZE)
    doppler_fft = _fft(range_fft, axis=0, size=DOPPLER_FFT_SIZE, shift=True)
    rd_map = np.sqrt(np.sum(np.abs(doppler_fft) ** 2, axis=(1, 2))).astype(np.float32)
    mask = _cfar(rd_map, 1, 2, 8, 4, 3, False, 15.0)
    mask &= _cfar(rd_map, 0, 0, 4, 2, 3, True, 15.0)
    mask &= _local_maxima(rd_map)
    points = []
    for doppler, range_bin in zip(*np.nonzero(mask)):
        range_m = float(range_bin) * RANGE_RES_M
        if range_m > 10.60:
            continue
        point = _xyz(doppler_fft[doppler, :, :, range_bin], range_m)
        if point is not None:
            points.append(point)
    if not points:
        return np.empty((0, 3), dtype=np.float32)
    return (_nearest_per_ray(np.stack(points, axis=0)) - CAMERA_POS_IN_RADAR_M).astype(np.float32)