Transform¶

def __post_init__(self) -> None:
    """Initialize the render distance dataclass."""
    if self.front <= 0.0:
        raise ValueError(f"'front' must be positive; got {self.front}.")

    if self.lateral <= 0.0:
        raise ValueError(f"'lateral' must be positive; got {self.lateral}.")

def get_distance(self, pixels: float) -> float:
    """Convert a pixel distance in the output image to meters.

    :param pixels: The distance in output pixels.
    :return: The equivalent distance in meters.
    """
    return pixels / self._pixels_per_meter

def get_pixels(self, meters: float) -> float:
    """Convert a physical distance in meters to output pixels.

    :param meters: The distance in meters.
    :return: The equivalent distance in output pixels.
    """
    return meters * self._pixels_per_meter

def get_distance_forward(self, y: int) -> float:
    """Return the forward distance in meters to a horizontal scanline.

    :param y: The y-coordinate of the scanline in the output image.
    :return: The distance in meters.
    """
    _, out_h = self._output_shape
    return self.get_distance(float(out_h - y))

def get_distance_to_point(self, x: int, y: int) -> float:
    """Return the Euclidean distance in meters from the camera to an output pixel.

    :param x: The x-coordinate of the output pixel.
    :param y: The y-coordinate of the output pixel.
    :return: The distance in meters.
    """
    out_w, out_h = self._output_shape
    return self.get_distance(math.hypot(x - out_w / 2.0, y - float(out_h)))

def get_distance_forward_to_camera_point(self, x: float, y: float, camera_idx: int) -> float:
    """Return the forward (depth) distance in meters to a point in a camera image.

    Only the projected y-coordinate in the output image is used, so lateral offset is ignored.

    :param x: The x-coordinate in the source camera image.
    :param y: The y-coordinate in the source camera image.
    :param camera_idx: The index of the source camera in the calibration.
    :return: The forward distance in meters.
    """
    _, out_y = self.transform_point(x, y, camera_idx)
    return self.get_distance_forward(out_y)

def get_distance_to_camera_point(self, x: float, y: float, camera_idx: int) -> float:
    """Return the Euclidean distance in meters from the camera to a point in a camera image.

    :param x: The x-coordinate in the source camera image.
    :param y: The y-coordinate in the source camera image.
    :param camera_idx: The index of the source camera in the calibration.
    :return: The Euclidean distance in meters.
    """
    out_x, out_y = self.transform_point(x, y, camera_idx)
    return self.get_distance_to_point(out_x, out_y)

def transform(self, images: list[npt.NDArray[np.uint8]]) -> npt.NDArray[np.uint8]:
    """Transform a list of camera images into a single top-down view.

    :param images: The camera images ordered to match the calibration.
    :return: The composited top-down image.
    """
    num_cameras = self._calibration.num_cameras
    if len(images) != num_cameras:
        raise ValueError(f"Expected {num_cameras} images, got {len(images)}.")

    self._canvas.fill(0)

    def _warp_camera(camera_idx: int) -> tuple[int, bool]:
        layer = self._warp_layers[camera_idx]
        if layer is None:
            return camera_idx, False

        _apply_remap(images[camera_idx], layer, self._interpolation)
        return camera_idx, True

    warp_results = (
        self._executor.map(_warp_camera, range(num_cameras))
        if self._executor is not None
        else map(_warp_camera, range(num_cameras))
    )

    for camera_idx, warped in warp_results:
        if not warped:
            continue

        layer = self._warp_layers[camera_idx]
        cv2.copyTo(layer.dst, layer.mask, self._canvas[layer.row_slice, layer.col_slice])

    return self._canvas

def transform_point(self, x: float, y: float, camera_idx: int) -> tuple[int, int]:
    """Transform a point from a camera image into the top-down output image.

    :param x: The x-coordinate in the source camera image.
    :param y: The y-coordinate in the source camera image.
    :param camera_idx: The index of the source camera in the calibration.
    :return: The ``(x, y)`` pixel coordinates in the top-down output image.
    """
    homography = self._camera_to_output[camera_idx]

    source_point = np.array([x, y, 1.0], dtype=np.float64)
    output_point = homography @ source_point
    if abs(output_point[2]) < _EPS:
        raise RuntimeError(f"Camera {camera_idx} point ({x}, {y}) projects onto the output horizon.")

    out_x = output_point[0] / output_point[2]
    out_y = output_point[1] / output_point[2]

    return int(round(out_x)), int(round(out_y))