Function ray_aabb_intersection

plib/utils.py:266–326

Check whether a ray intersect with an axis-aligned bounding box. Args: ray_origin: (3,) a point on the ray (with t = 0) ray_direction: (3,) ray direction bbox_min_bounds: (3,) top left corner bbox_max_bounds:

(
        ray_origin: torch.Tensor,
        ray_direction: torch.Tensor,
        bbox_min_bounds: torch.Tensor,
        bbox_max_bounds: torch.Tensor,
        bbox_scaling_ratio: float = 1.0,
        t_min: float = 0.,
        t_max: float = 1.0e10,
)

def ray_aabb_intersection(
        ray_origin: torch.Tensor,
        ray_direction: torch.Tensor,
        bbox_min_bounds: torch.Tensor,
        bbox_max_bounds: torch.Tensor,
        bbox_scaling_ratio: float = 1.0,
        t_min: float = 0.,
        t_max: float = 1.0e10,
) -> T.Dict[str, T.Any]:
    """
    Check whether a ray intersect with an axis-aligned bounding box.

    Args:
        ray_origin:
            (3,) a point on the ray (with t = 0)
        ray_direction:
            (3,) ray direction
        bbox_min_bounds:
            (3,)  top left corner
        bbox_max_bounds:
            (3,)  bottom right corner.  The bbox encloses bbox_min_bounds to bbox_max_bounds.
        bbox_scaling_ratio:
            a scalar where we will scale the bbox wrt to its center.
        t_min:
            min t to consider
        t_max:
            max t to consider

    Returns:
        is_intersected: True if intersect.
        t0: first intersection t
        t1: second intersection t
    """

    # scale bbox
    bbox_center = 0.5 * (bbox_min_bounds + bbox_max_bounds)
    bbox_min_bounds = bbox_center + (bbox_min_bounds - bbox_center) * bbox_scaling_ratio
    bbox_max_bounds = bbox_center + (bbox_max_bounds - bbox_center) * bbox_scaling_ratio

    inv_ray_direction = 1. / ray_direction  # (3,)
    _t_nears = (bbox_min_bounds - ray_origin) * inv_ray_direction  # (3,)
    _t_fars = (bbox_max_bounds - ray_origin) * inv_ray_direction  # (3,)

    t_nears = torch.where(_t_nears > _t_fars, _t_fars, _t_nears)
    t_fars = torch.where(_t_nears > _t_fars, _t_nears, _t_fars)

    t_nears[torch.isnan(t_nears)] = -torch.inf
    t_fars[torch.isnan(t_fars)] = torch.inf

    t_near = torch.max(t_nears)  # scalar, use fmin to ignore nan, no need for max
    t_far = torch.min(t_fars)  # scalar, use fmax to ignore nan, no need for min

    t_near = torch.max(t_near, torch.ones_like(t_near) * t_min)
    t_far = torch.min(t_far, torch.ones_like(t_far) * t_max)

    is_intersect = t_near <= t_far
    return dict(
        is_intersected=is_intersect,