//  [python]
def random_shift_bbox(image, bbox, pixel_scaling, replace,
                      new_min_bbox_coords=None):
    """Move the bbox and the image content to a slightly new random location.

    Args:
        image: 3D uint8 Tensor.
        bbox: 1D Tensor that has 4 elements (min_y, min_x, max_y, max_x)
            of type float that represents the normalized coordinates between 0 and 1.
            The potential values for the new min corner of the bbox will be between
            [old_min - pixel_scaling * bbox_height/2,
             old_min - pixel_scaling * bbox_height/2].
        pixel_scaling: A float between 0 and 1 that specifies the pixel range
            that the new bbox location will be sampled from.
        replace: A one or three value 1D tensor to fill empty pixels.
        new_min_bbox_coords: If not None, then this is a tuple that specifies the
            (min_y, min_x) coordinates of the new bbox. Normally this is randomly
            specified, but this allows it to be manually set. The coordinates are
            the absolute coordinates between 0 and image height/width and are int32.

    Returns:
        The new image that will have the shifted bbox location in it along with
        the new bbox that contains the new coordinates.
    """
    # Obtains image height and width and create helper clip functions.
    image_height = tf.to_float(tf.shape(image)[0])
    image_width = tf.to_float(tf.shape(image)[1])

    def clip_y(val):
        return tf.clip_by_value(val, 0, tf.to_int32(image_height) - 1)

    def clip_x(val):
        return tf.clip_by_value(val, 0, tf.to_int32(image_width) - 1)

    # Convert bbox to pixel coordinates.
    min_y = tf.to_int32(image_height * bbox[0])
    min_x = tf.to_int32(image_width * bbox[1])
    max_y = clip_y(tf.to_int32(image_height * bbox[2]))
    max_x = clip_x(tf.to_int32(image_width * bbox[3]))
    bbox_height, bbox_width = (max_y - min_y + 1, max_x - min_x + 1)
    image_height = tf.to_int32(image_height)
    image_width = tf.to_int32(image_width)

    # Select the new min/max bbox ranges that are used for sampling the
    # new min x/y coordinates of the shifted bbox.
    minval_y = clip_y(
        min_y - tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))
    maxval_y = clip_y(
        min_y + tf.to_int32(pixel_scaling * tf.to_float(bbox_height) / 2.0))
    minval_x = clip_x(
        min_x - tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))
    maxval_x = clip_x(
        min_x + tf.to_int32(pixel_scaling * tf.to_float(bbox_width) / 2.0))

    # Sample and calculate the new unclipped min/max coordinates of the new bbox.
    if new_min_bbox_coords is None:
        unclipped_new_min_y = tf.random_uniform(
            shape=[], minval=minval_y, maxval=maxval_y,
            dtype=tf.int32)
        unclipped_new_min_x = tf.random_uniform(
            shape=[], minval=minval_x, maxval=maxval_x,
            dtype=tf.int32)
    else:
        unclipped_new_min_y, unclipped_new_min_x = (
            clip_y(new_min_bbox_coords[0]), clip_x(new_min_bbox_coords[1]))
    unclipped_new_max_y = unclipped_new_min_y + bbox_height - 1
    unclipped_new_max_x = unclipped_new_min_x + bbox_width - 1

    # Determine if any of the new bbox was shifted outside the current image.
    # This is used for determining if any of the original bbox content should be
    # discarded.
    new_min_y, new_min_x, new_max_y, new_max_x = (
        clip_y(unclipped_new_min_y), clip_x(unclipped_new_min_x),
        clip_y(unclipped_new_max_y), clip_x(unclipped_new_max_x))
    shifted_min_y = (new_min_y - unclipped_new_min_y) + min_y
    shifted_max_y = max_y - (unclipped_new_max_y - new_max_y)
    shifted_min_x = (new_min_x - unclipped_new_min_x) + min_x
    shifted_max_x = max_x - (unclipped_new_max_x - new_max_x)

    # Create the new bbox tensor by converting pixel integer values to floats.
    new_bbox = tf.stack([
        tf.to_float(new_min_y) / tf.to_float(image_height),
        tf.to_float(new_min_x) / tf.to_float(image_width),
        tf.to_float(new_max_y) / tf.to_float(image_height),
        tf.to_float(new_max_x) / tf.to_float(image_width)])

    # Copy the contents in the bbox and fill the old bbox location
    # with gray (128).
    bbox_content = image[shifted_min_y:shifted_max_y + 1,
                         shifted_min_x:shifted_max_x + 1, :]

    def mask_and_add_image(
            min_y_, min_x_, max_y_, max_x_, mask, content_tensor, image_):
        """Applies mask to bbox region in image then adds content_tensor to it."""
        mask = tf.pad(
            mask,
            [[min_y_, (image_height - 1) - max_y_],
             [min_x_, (image_width - 1) - max_x_],
             [0, 0]],
            constant_values=1)
        content_tensor = tf.pad(
            content_tensor,
            [[min_y_, (image_height - 1) - max_y_],
             [min_x_, (image_width - 1) - max_x_],
             [0, 0]],
            constant_values=0)
        return image_ * mask + content_tensor

    # Zero out original bbox location.
    mask = tf.zeros_like(image)[min_y:max_y + 1, min_x:max_x + 1, :]
    grey_tensor = tf.zeros_like(mask) + replace[0]
    image = mask_and_add_image(min_y, min_x, max_y, max_x, mask,
                               grey_tensor, image)

    # Fill in bbox content to new bbox location.
    mask = tf.zeros_like(bbox_content)
    image = mask_and_add_image(
        new_min_y, new_min_x, new_max_y, new_max_x, mask, bbox_content, image)

    return image, new_bbox