evalio.rerun

Functions:

• convert –

  Convert a variety of objects to rerun types.

convert

convert(
    obj: LidarMeasurement,
    color: Optional[
        Literal["z", "intensity"]
        | tuple[int, int, int]
        | tuple[float, float, float]
    ] = None,
    radii: Optional[float] = None,
) -> Points3D

convert(
    obj: list[Point],
    color: Optional[
        Literal["z", "intensity"]
        | tuple[int, int, int]
        | tuple[float, float, float]
    ] = None,
    radii: Optional[float] = None,
) -> Points3D

convert(
    obj: NDArray[float64],
    color: Optional[Literal["z"] | NDArray[float64]] = None,
    radii: Optional[float] = None,
) -> Points3D

convert(
    obj: list[SE3],
    color: Optional[
        tuple[int, int, int] | tuple[float, float, float]
    ] = None,
) -> Points3D

convert(
    obj: Trajectory[M],
    color: Optional[
        tuple[int, int, int] | tuple[float, float, float]
    ] = None,
) -> Points3D

convert(obj: SE3) -> Transform3D

convert(
    obj: Any,
    color: Optional[Any] = None,
    radii: Optional[float] = None,
) -> Transform3D | Points3D

Convert a variety of objects to rerun types.

Parameters:

• obj (object) –

  Object to convert. Can be a LidarMeasurement, list of Points, numpy array, SE3, or Trajectory.

• color (Optional[Any], default: None ) –

  Optional color to set. See overloads for additional literal options. Defaults to None.

Raises:

• ValueError –

  If the color pass is invalid.

• ValueError –

  If the object is not an implemented type for conversion.

Returns:

• Transform3D | Points3D –

  Rerun type.

Source code in python/evalio/rerun.py

def convert(
    obj: Any,
    color: Optional[Any] = None,
    radii: Optional[float] = None,
) -> rr.Transform3D | rr.Points3D:
    """Convert a variety of objects to rerun types.

    Args:
        obj (object): Object to convert. Can be a LidarMeasurement, list of Points, numpy array, SE3, or Trajectory.
        color (Optional[Any], optional): Optional color to set. See overloads for additional literal options. Defaults to None.

    Raises:
        ValueError: If the color pass is invalid.
        ValueError: If the object is not an implemented type for conversion.

    Returns:
        Rerun type.
    """
    # If we have an empty list, assume it's a point cloud with no points
    if isinstance(obj, list) and len(obj) == 0:  # type: ignore
        return rr.Points3D(np.zeros((0, 3)), colors=color, radii=radii)

    # Handle point clouds
    if isinstance(obj, LidarMeasurement):
        color_parsed = None
        if isinstance(color, tuple):
            color = cast(tuple[int, int, int], color)
            color_parsed = np.asarray(color)
        elif color == "intensity":
            max_intensity = max([p.intensity for p in obj.points])
            color_parsed = np.zeros((len(obj.points), 3))
            for i, point in enumerate(obj.points):
                val = point.intensity / max_intensity
                color_parsed[i] = [1.0 - val, val, 0]
        elif color == "z":
            zs = [p.z for p in obj.points]
            min_z, max_z = min(zs), max(zs)
            color_parsed = np.zeros((len(obj.points), 3))
            for i, point in enumerate(obj.points):
                val = (point.z - min_z) / (max_z - min_z)
                color_parsed[i] = [1.0 - val, val, 0]
        elif color is not None:
            raise ValueError(f"Unknown color type {color}")

        return convert(
            np.asarray(obj.to_vec_positions()), color=color_parsed, radii=radii
        )

    elif isinstance(obj, list) and isinstance(obj[0], Point):
        obj = cast(list[Point], obj)
        return convert(
            LidarMeasurement(Stamp.from_sec(0), obj), color=color, radii=radii
        )

    elif isinstance(obj, np.ndarray) and len(obj.shape) == 2 and obj.shape[1] == 3:  # type: ignore
        obj = cast(NDArray[np.float64], obj)
        if isinstance(color, str) and color == "z":
            zs = obj[:, 2]
            min_z, max_z = min(zs), max(zs)
            color = np.zeros_like(obj)
            color = cast(NDArray[np.float64], color)

            val = (zs - min_z) / (max_z - min_z)
            color[:, 0] = 1.0 - val
            color[:, 1] = val

        return rr.Points3D(obj, colors=color, radii=radii)

    # Handle poses
    elif isinstance(obj, SE3):
        return rr.Transform3D(
            rotation=rr.datatypes.Quaternion(
                xyzw=[
                    obj.rot.qx,
                    obj.rot.qy,
                    obj.rot.qz,
                    obj.rot.qw,
                ]
            ),
            translation=obj.trans,
        )
    elif isinstance(obj, Trajectory):
        return convert(obj.poses, color=color)
    elif isinstance(obj, list) and isinstance(obj[0], SE3):
        obj = cast(list[SE3], obj)
        points = np.zeros((len(obj), 3))
        for i, pose in enumerate(obj):
            points[i] = pose.trans
        return rr.Points3D(points, colors=color)

    else:
        raise ValueError(f"Cannot convert {type(obj)} to rerun type")  # type: ignore