docs: def pad_to_bounding_box(image, offset_height, offset_width, target_height,
                          target_width, dynamic_shape=False):
    """Pad `image` with zeros to the specified `height` and `width`.
  
    Adds `offset_height` rows of zeros on top, `offset_width` columns of
    zeros on the left, and then pads the image on the bottom and right
    with zeros until it has dimensions `target_height`, `target_width`.
  
    This op does nothing if `offset_*` is zero and the image already has size
    `target_height` by `target_width`.
  
    Args:
      image: 3-D tensor with shape `[height, width, channels]`
      offset_height: Number of rows of zeros to add on top.
      offset_width: Number of columns of zeros to add on the left.
      target_height: Height of output image.
      target_width: Width of output image.
      dynamic_shape: Whether the input image has undertermined shape. If set to
        `True`, shape information will be retrieved at run time. Default to
        `False`.
  
    Returns:
      3-D tensor of shape `[target_height, target_width, channels]`
    Raises:
      ValueError: If the shape of `image` is incompatible with the `offset_*` or
        `target_*` arguments, and `dynamic_shape` is set to `False`.
    """
    image = ops.convert_to_tensor(image, name='image')
    _Check3DImage(image, require_static=(not dynamic_shape))
    height, width, depth = _ImageDimensions(image, dynamic_shape=dynamic_shape)
  
    after_padding_width = target_width - offset_width - width
    after_padding_height = target_height - offset_height - height
  
    if not dynamic_shape:
      if target_width < width:
        raise ValueError('target_width must be >= width')
      if target_height < height:
        raise ValueError('target_height must be >= height')
  
      if after_padding_width < 0:
        raise ValueError('target_width not possible given '
                         'offset_width and image width')
      if after_padding_height < 0:
        raise ValueError('target_height not possible given '
                         'offset_height and image height')
  
    # Do not pad on the depth dimensions.
    if (dynamic_shape or offset_width or offset_height or
        after_padding_width or after_padding_height):
      paddings = array_ops.reshape(
        array_ops.pack([offset_height, after_padding_height,
                        offset_width, after_padding_width,
                        0, 0]),
        [3, 2])
      padded = array_ops.pad(image, paddings)
      if not dynamic_shape:
        padded.set_shape([target_height, target_width, depth])
    else:
      padded = image
  
    return padded