Spaces:
Running
on
T4
Running
on
T4
# coding=utf-8 | |
# Copyright 2022 The HuggingFace Inc. team. | |
# | |
# Licensed under the Apache License, Version 2.0 (the "License"); | |
# you may not use this file except in compliance with the License. | |
# You may obtain a copy of the License at | |
# | |
# http://www.apache.org/licenses/LICENSE-2.0 | |
# | |
# Unless required by applicable law or agreed to in writing, software | |
# distributed under the License is distributed on an "AS IS" BASIS, | |
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
# See the License for the specific language governing permissions and | |
# limitations under the License. | |
import warnings | |
from typing import Iterable, List, Optional, Tuple, Union | |
import numpy as np | |
from .image_utils import ( | |
ChannelDimension, | |
ImageInput, | |
get_channel_dimension_axis, | |
get_image_size, | |
infer_channel_dimension_format, | |
) | |
from .utils import ExplicitEnum, TensorType, is_jax_tensor, is_tf_tensor, is_torch_tensor | |
from .utils.import_utils import ( | |
is_flax_available, | |
is_tf_available, | |
is_torch_available, | |
is_vision_available, | |
requires_backends, | |
) | |
if is_vision_available(): | |
import PIL | |
from .image_utils import PILImageResampling | |
if is_torch_available(): | |
import torch | |
if is_tf_available(): | |
import tensorflow as tf | |
if is_flax_available(): | |
import jax.numpy as jnp | |
def to_channel_dimension_format( | |
image: np.ndarray, | |
channel_dim: Union[ChannelDimension, str], | |
input_channel_dim: Optional[Union[ChannelDimension, str]] = None, | |
) -> np.ndarray: | |
""" | |
Converts `image` to the channel dimension format specified by `channel_dim`. | |
Args: | |
image (`numpy.ndarray`): | |
The image to have its channel dimension set. | |
channel_dim (`ChannelDimension`): | |
The channel dimension format to use. | |
input_channel_dim (`ChannelDimension`, *optional*): | |
The channel dimension format of the input image. If not provided, it will be inferred from the input image. | |
Returns: | |
`np.ndarray`: The image with the channel dimension set to `channel_dim`. | |
""" | |
if not isinstance(image, np.ndarray): | |
raise ValueError(f"Input image must be of type np.ndarray, got {type(image)}") | |
if input_channel_dim is None: | |
input_channel_dim = infer_channel_dimension_format(image) | |
target_channel_dim = ChannelDimension(channel_dim) | |
if input_channel_dim == target_channel_dim: | |
return image | |
if target_channel_dim == ChannelDimension.FIRST: | |
image = image.transpose((2, 0, 1)) | |
elif target_channel_dim == ChannelDimension.LAST: | |
image = image.transpose((1, 2, 0)) | |
else: | |
raise ValueError("Unsupported channel dimension format: {}".format(channel_dim)) | |
return image | |
def rescale( | |
image: np.ndarray, | |
scale: float, | |
data_format: Optional[ChannelDimension] = None, | |
dtype: np.dtype = np.float32, | |
input_data_format: Optional[Union[str, ChannelDimension]] = None, | |
) -> np.ndarray: | |
""" | |
Rescales `image` by `scale`. | |
Args: | |
image (`np.ndarray`): | |
The image to rescale. | |
scale (`float`): | |
The scale to use for rescaling the image. | |
data_format (`ChannelDimension`, *optional*): | |
The channel dimension format of the image. If not provided, it will be the same as the input image. | |
dtype (`np.dtype`, *optional*, defaults to `np.float32`): | |
The dtype of the output image. Defaults to `np.float32`. Used for backwards compatibility with feature | |
extractors. | |
input_data_format (`ChannelDimension`, *optional*): | |
The channel dimension format of the input image. If not provided, it will be inferred from the input image. | |
Returns: | |
`np.ndarray`: The rescaled image. | |
""" | |
if not isinstance(image, np.ndarray): | |
raise ValueError(f"Input image must be of type np.ndarray, got {type(image)}") | |
rescaled_image = image * scale | |
if data_format is not None: | |
rescaled_image = to_channel_dimension_format(rescaled_image, data_format, input_data_format) | |
rescaled_image = rescaled_image.astype(dtype) | |
return rescaled_image | |
def _rescale_for_pil_conversion(image): | |
""" | |
Detects whether or not the image needs to be rescaled before being converted to a PIL image. | |
The assumption is that if the image is of type `np.float` and all values are between 0 and 1, it needs to be | |
rescaled. | |
""" | |
if image.dtype == np.uint8: | |
do_rescale = False | |
elif np.allclose(image, image.astype(int)): | |
if np.all(0 <= image) and np.all(image <= 255): | |
do_rescale = False | |
else: | |
raise ValueError( | |
"The image to be converted to a PIL image contains values outside the range [0, 255], " | |
f"got [{image.min()}, {image.max()}] which cannot be converted to uint8." | |
) | |
elif np.all(0 <= image) and np.all(image <= 1): | |
do_rescale = True | |
else: | |
raise ValueError( | |
"The image to be converted to a PIL image contains values outside the range [0, 1], " | |
f"got [{image.min()}, {image.max()}] which cannot be converted to uint8." | |
) | |
return do_rescale | |
def to_pil_image( | |
image: Union[np.ndarray, "PIL.Image.Image", "torch.Tensor", "tf.Tensor", "jnp.ndarray"], | |
do_rescale: Optional[bool] = None, | |
input_data_format: Optional[Union[str, ChannelDimension]] = None, | |
) -> "PIL.Image.Image": | |
""" | |
Converts `image` to a PIL Image. Optionally rescales it and puts the channel dimension back as the last axis if | |
needed. | |
Args: | |
image (`PIL.Image.Image` or `numpy.ndarray` or `torch.Tensor` or `tf.Tensor`): | |
The image to convert to the `PIL.Image` format. | |
do_rescale (`bool`, *optional*): | |
Whether or not to apply the scaling factor (to make pixel values integers between 0 and 255). Will default | |
to `True` if the image type is a floating type and casting to `int` would result in a loss of precision, | |
and `False` otherwise. | |
input_data_format (`ChannelDimension`, *optional*): | |
The channel dimension format of the input image. If unset, will use the inferred format from the input. | |
Returns: | |
`PIL.Image.Image`: The converted image. | |
""" | |
requires_backends(to_pil_image, ["vision"]) | |
if isinstance(image, PIL.Image.Image): | |
return image | |
# Convert all tensors to numpy arrays before converting to PIL image | |
if is_torch_tensor(image) or is_tf_tensor(image): | |
image = image.numpy() | |
elif is_jax_tensor(image): | |
image = np.array(image) | |
elif not isinstance(image, np.ndarray): | |
raise ValueError("Input image type not supported: {}".format(type(image))) | |
# If the channel as been moved to first dim, we put it back at the end. | |
image = to_channel_dimension_format(image, ChannelDimension.LAST, input_data_format) | |
# If there is a single channel, we squeeze it, as otherwise PIL can't handle it. | |
image = np.squeeze(image, axis=-1) if image.shape[-1] == 1 else image | |
# PIL.Image can only store uint8 values so we rescale the image to be between 0 and 255 if needed. | |
do_rescale = _rescale_for_pil_conversion(image) if do_rescale is None else do_rescale | |
if do_rescale: | |
image = rescale(image, 255) | |
image = image.astype(np.uint8) | |
return PIL.Image.fromarray(image) | |
# Logic adapted from torchvision resizing logic: https://github.com/pytorch/vision/blob/511924c1ced4ce0461197e5caa64ce5b9e558aab/torchvision/transforms/functional.py#L366 | |
def get_resize_output_image_size( | |
input_image: np.ndarray, | |
size: Union[int, Tuple[int, int], List[int], Tuple[int]], | |
default_to_square: bool = True, | |
max_size: Optional[int] = None, | |
input_data_format: Optional[Union[str, ChannelDimension]] = None, | |
) -> tuple: | |
""" | |
Find the target (height, width) dimension of the output image after resizing given the input image and the desired | |
size. | |
Args: | |
input_image (`np.ndarray`): | |
The image to resize. | |
size (`int` or `Tuple[int, int]` or List[int] or Tuple[int]): | |
The size to use for resizing the image. If `size` is a sequence like (h, w), output size will be matched to | |
this. | |
If `size` is an int and `default_to_square` is `True`, then image will be resized to (size, size). If | |
`size` is an int and `default_to_square` is `False`, then smaller edge of the image will be matched to this | |
number. i.e, if height > width, then image will be rescaled to (size * height / width, size). | |
default_to_square (`bool`, *optional*, defaults to `True`): | |
How to convert `size` when it is a single int. If set to `True`, the `size` will be converted to a square | |
(`size`,`size`). If set to `False`, will replicate | |
[`torchvision.transforms.Resize`](https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.Resize) | |
with support for resizing only the smallest edge and providing an optional `max_size`. | |
max_size (`int`, *optional*): | |
The maximum allowed for the longer edge of the resized image: if the longer edge of the image is greater | |
than `max_size` after being resized according to `size`, then the image is resized again so that the longer | |
edge is equal to `max_size`. As a result, `size` might be overruled, i.e the smaller edge may be shorter | |
than `size`. Only used if `default_to_square` is `False`. | |
input_data_format (`ChannelDimension`, *optional*): | |
The channel dimension format of the input image. If unset, will use the inferred format from the input. | |
Returns: | |
`tuple`: The target (height, width) dimension of the output image after resizing. | |
""" | |
if isinstance(size, (tuple, list)): | |
if len(size) == 2: | |
return tuple(size) | |
elif len(size) == 1: | |
# Perform same logic as if size was an int | |
size = size[0] | |
else: | |
raise ValueError("size must have 1 or 2 elements if it is a list or tuple") | |
if default_to_square: | |
return (size, size) | |
height, width = get_image_size(input_image, input_data_format) | |
short, long = (width, height) if width <= height else (height, width) | |
requested_new_short = size | |
new_short, new_long = requested_new_short, int(requested_new_short * long / short) | |
if max_size is not None: | |
if max_size <= requested_new_short: | |
raise ValueError( | |
f"max_size = {max_size} must be strictly greater than the requested " | |
f"size for the smaller edge size = {size}" | |
) | |
if new_long > max_size: | |
new_short, new_long = int(max_size * new_short / new_long), max_size | |
return (new_long, new_short) if width <= height else (new_short, new_long) | |
def resize( | |
image, | |
size: Tuple[int, int], | |
resample: "PILImageResampling" = None, | |
reducing_gap: Optional[int] = None, | |
data_format: Optional[ChannelDimension] = None, | |
return_numpy: bool = True, | |
input_data_format: Optional[Union[str, ChannelDimension]] = None, | |
) -> np.ndarray: | |
""" | |
Resizes `image` to `(height, width)` specified by `size` using the PIL library. | |
Args: | |
image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`): | |
The image to resize. | |
size (`Tuple[int, int]`): | |
The size to use for resizing the image. | |
resample (`int`, *optional*, defaults to `PILImageResampling.BILINEAR`): | |
The filter to user for resampling. | |
reducing_gap (`int`, *optional*): | |
Apply optimization by resizing the image in two steps. The bigger `reducing_gap`, the closer the result to | |
the fair resampling. See corresponding Pillow documentation for more details. | |
data_format (`ChannelDimension`, *optional*): | |
The channel dimension format of the output image. If unset, will use the inferred format from the input. | |
return_numpy (`bool`, *optional*, defaults to `True`): | |
Whether or not to return the resized image as a numpy array. If False a `PIL.Image.Image` object is | |
returned. | |
input_data_format (`ChannelDimension`, *optional*): | |
The channel dimension format of the input image. If unset, will use the inferred format from the input. | |
Returns: | |
`np.ndarray`: The resized image. | |
""" | |
requires_backends(resize, ["vision"]) | |
resample = resample if resample is not None else PILImageResampling.BILINEAR | |
if not len(size) == 2: | |
raise ValueError("size must have 2 elements") | |
# For all transformations, we want to keep the same data format as the input image unless otherwise specified. | |
# The resized image from PIL will always have channels last, so find the input format first. | |
if input_data_format is None: | |
input_data_format = infer_channel_dimension_format(image) | |
data_format = input_data_format if data_format is None else data_format | |
# To maintain backwards compatibility with the resizing done in previous image feature extractors, we use | |
# the pillow library to resize the image and then convert back to numpy | |
do_rescale = False | |
if not isinstance(image, PIL.Image.Image): | |
do_rescale = _rescale_for_pil_conversion(image) | |
image = to_pil_image(image, do_rescale=do_rescale, input_data_format=input_data_format) | |
height, width = size | |
# PIL images are in the format (width, height) | |
resized_image = image.resize((width, height), resample=resample, reducing_gap=reducing_gap) | |
if return_numpy: | |
resized_image = np.array(resized_image) | |
# If the input image channel dimension was of size 1, then it is dropped when converting to a PIL image | |
# so we need to add it back if necessary. | |
resized_image = np.expand_dims(resized_image, axis=-1) if resized_image.ndim == 2 else resized_image | |
# The image is always in channels last format after converting from a PIL image | |
resized_image = to_channel_dimension_format( | |
resized_image, data_format, input_channel_dim=ChannelDimension.LAST | |
) | |
# If an image was rescaled to be in the range [0, 255] before converting to a PIL image, then we need to | |
# rescale it back to the original range. | |
resized_image = rescale(resized_image, 1 / 255) if do_rescale else resized_image | |
return resized_image | |
def normalize( | |
image: np.ndarray, | |
mean: Union[float, Iterable[float]], | |
std: Union[float, Iterable[float]], | |
data_format: Optional[ChannelDimension] = None, | |
input_data_format: Optional[Union[str, ChannelDimension]] = None, | |
) -> np.ndarray: | |
""" | |
Normalizes `image` using the mean and standard deviation specified by `mean` and `std`. | |
image = (image - mean) / std | |
Args: | |
image (`np.ndarray`): | |
The image to normalize. | |
mean (`float` or `Iterable[float]`): | |
The mean to use for normalization. | |
std (`float` or `Iterable[float]`): | |
The standard deviation to use for normalization. | |
data_format (`ChannelDimension`, *optional*): | |
The channel dimension format of the output image. If unset, will use the inferred format from the input. | |
input_data_format (`ChannelDimension`, *optional*): | |
The channel dimension format of the input image. If unset, will use the inferred format from the input. | |
""" | |
if not isinstance(image, np.ndarray): | |
raise ValueError("image must be a numpy array") | |
if input_data_format is None: | |
input_data_format = infer_channel_dimension_format(image) | |
channel_axis = get_channel_dimension_axis(image, input_data_format=input_data_format) | |
num_channels = image.shape[channel_axis] | |
if isinstance(mean, Iterable): | |
if len(mean) != num_channels: | |
raise ValueError(f"mean must have {num_channels} elements if it is an iterable, got {len(mean)}") | |
else: | |
mean = [mean] * num_channels | |
mean = np.array(mean, dtype=image.dtype) | |
if isinstance(std, Iterable): | |
if len(std) != num_channels: | |
raise ValueError(f"std must have {num_channels} elements if it is an iterable, got {len(std)}") | |
else: | |
std = [std] * num_channels | |
std = np.array(std, dtype=image.dtype) | |
if input_data_format == ChannelDimension.LAST: | |
image = (image - mean) / std | |
else: | |
image = ((image.T - mean) / std).T | |
image = to_channel_dimension_format(image, data_format, input_data_format) if data_format is not None else image | |
return image | |
def center_crop( | |
image: np.ndarray, | |
size: Tuple[int, int], | |
data_format: Optional[Union[str, ChannelDimension]] = None, | |
input_data_format: Optional[Union[str, ChannelDimension]] = None, | |
return_numpy: Optional[bool] = None, | |
) -> np.ndarray: | |
""" | |
Crops the `image` to the specified `size` using a center crop. Note that if the image is too small to be cropped to | |
the size given, it will be padded (so the returned result will always be of size `size`). | |
Args: | |
image (`np.ndarray`): | |
The image to crop. | |
size (`Tuple[int, int]`): | |
The target size for the cropped image. | |
data_format (`str` or `ChannelDimension`, *optional*): | |
The channel dimension format for the output image. Can be one of: | |
- `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. | |
- `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. | |
If unset, will use the inferred format of the input image. | |
input_data_format (`str` or `ChannelDimension`, *optional*): | |
The channel dimension format for the input image. Can be one of: | |
- `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. | |
- `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. | |
If unset, will use the inferred format of the input image. | |
return_numpy (`bool`, *optional*): | |
Whether or not to return the cropped image as a numpy array. Used for backwards compatibility with the | |
previous ImageFeatureExtractionMixin method. | |
- Unset: will return the same type as the input image. | |
- `True`: will return a numpy array. | |
- `False`: will return a `PIL.Image.Image` object. | |
Returns: | |
`np.ndarray`: The cropped image. | |
""" | |
requires_backends(center_crop, ["vision"]) | |
if return_numpy is not None: | |
warnings.warn("return_numpy is deprecated and will be removed in v.4.33", FutureWarning) | |
return_numpy = True if return_numpy is None else return_numpy | |
if not isinstance(image, np.ndarray): | |
raise ValueError(f"Input image must be of type np.ndarray, got {type(image)}") | |
if not isinstance(size, Iterable) or len(size) != 2: | |
raise ValueError("size must have 2 elements representing the height and width of the output image") | |
if input_data_format is None: | |
input_data_format = infer_channel_dimension_format(image) | |
output_data_format = data_format if data_format is not None else input_data_format | |
# We perform the crop in (C, H, W) format and then convert to the output format | |
image = to_channel_dimension_format(image, ChannelDimension.FIRST, input_data_format) | |
orig_height, orig_width = get_image_size(image, ChannelDimension.FIRST) | |
crop_height, crop_width = size | |
crop_height, crop_width = int(crop_height), int(crop_width) | |
# In case size is odd, (image_shape[0] + size[0]) // 2 won't give the proper result. | |
top = (orig_height - crop_height) // 2 | |
bottom = top + crop_height | |
# In case size is odd, (image_shape[1] + size[1]) // 2 won't give the proper result. | |
left = (orig_width - crop_width) // 2 | |
right = left + crop_width | |
# Check if cropped area is within image boundaries | |
if top >= 0 and bottom <= orig_height and left >= 0 and right <= orig_width: | |
image = image[..., top:bottom, left:right] | |
image = to_channel_dimension_format(image, output_data_format, ChannelDimension.FIRST) | |
return image | |
# Otherwise, we may need to pad if the image is too small. Oh joy... | |
new_height = max(crop_height, orig_height) | |
new_width = max(crop_width, orig_width) | |
new_shape = image.shape[:-2] + (new_height, new_width) | |
new_image = np.zeros_like(image, shape=new_shape) | |
# If the image is too small, pad it with zeros | |
top_pad = (new_height - orig_height) // 2 | |
bottom_pad = top_pad + orig_height | |
left_pad = (new_width - orig_width) // 2 | |
right_pad = left_pad + orig_width | |
new_image[..., top_pad:bottom_pad, left_pad:right_pad] = image | |
top += top_pad | |
bottom += top_pad | |
left += left_pad | |
right += left_pad | |
new_image = new_image[..., max(0, top) : min(new_height, bottom), max(0, left) : min(new_width, right)] | |
new_image = to_channel_dimension_format(new_image, output_data_format, ChannelDimension.FIRST) | |
if not return_numpy: | |
new_image = to_pil_image(new_image) | |
return new_image | |
def _center_to_corners_format_torch(bboxes_center: "torch.Tensor") -> "torch.Tensor": | |
center_x, center_y, width, height = bboxes_center.unbind(-1) | |
bbox_corners = torch.stack( | |
# top left x, top left y, bottom right x, bottom right y | |
[(center_x - 0.5 * width), (center_y - 0.5 * height), (center_x + 0.5 * width), (center_y + 0.5 * height)], | |
dim=-1, | |
) | |
return bbox_corners | |
def _center_to_corners_format_numpy(bboxes_center: np.ndarray) -> np.ndarray: | |
center_x, center_y, width, height = bboxes_center.T | |
bboxes_corners = np.stack( | |
# top left x, top left y, bottom right x, bottom right y | |
[center_x - 0.5 * width, center_y - 0.5 * height, center_x + 0.5 * width, center_y + 0.5 * height], | |
axis=-1, | |
) | |
return bboxes_corners | |
def _center_to_corners_format_tf(bboxes_center: "tf.Tensor") -> "tf.Tensor": | |
center_x, center_y, width, height = tf.unstack(bboxes_center, axis=-1) | |
bboxes_corners = tf.stack( | |
# top left x, top left y, bottom right x, bottom right y | |
[center_x - 0.5 * width, center_y - 0.5 * height, center_x + 0.5 * width, center_y + 0.5 * height], | |
axis=-1, | |
) | |
return bboxes_corners | |
# 2 functions below inspired by https://github.com/facebookresearch/detr/blob/master/util/box_ops.py | |
def center_to_corners_format(bboxes_center: TensorType) -> TensorType: | |
""" | |
Converts bounding boxes from center format to corners format. | |
center format: contains the coordinate for the center of the box and its width, height dimensions | |
(center_x, center_y, width, height) | |
corners format: contains the coodinates for the top-left and bottom-right corners of the box | |
(top_left_x, top_left_y, bottom_right_x, bottom_right_y) | |
""" | |
# Function is used during model forward pass, so we use the input framework if possible, without | |
# converting to numpy | |
if is_torch_tensor(bboxes_center): | |
return _center_to_corners_format_torch(bboxes_center) | |
elif isinstance(bboxes_center, np.ndarray): | |
return _center_to_corners_format_numpy(bboxes_center) | |
elif is_tf_tensor(bboxes_center): | |
return _center_to_corners_format_tf(bboxes_center) | |
raise ValueError(f"Unsupported input type {type(bboxes_center)}") | |
def _corners_to_center_format_torch(bboxes_corners: "torch.Tensor") -> "torch.Tensor": | |
top_left_x, top_left_y, bottom_right_x, bottom_right_y = bboxes_corners.unbind(-1) | |
b = [ | |
(top_left_x + bottom_right_x) / 2, # center x | |
(top_left_y + bottom_right_y) / 2, # center y | |
(bottom_right_x - top_left_x), # width | |
(bottom_right_y - top_left_y), # height | |
] | |
return torch.stack(b, dim=-1) | |
def _corners_to_center_format_numpy(bboxes_corners: np.ndarray) -> np.ndarray: | |
top_left_x, top_left_y, bottom_right_x, bottom_right_y = bboxes_corners.T | |
bboxes_center = np.stack( | |
[ | |
(top_left_x + bottom_right_x) / 2, # center x | |
(top_left_y + bottom_right_y) / 2, # center y | |
(bottom_right_x - top_left_x), # width | |
(bottom_right_y - top_left_y), # height | |
], | |
axis=-1, | |
) | |
return bboxes_center | |
def _corners_to_center_format_tf(bboxes_corners: "tf.Tensor") -> "tf.Tensor": | |
top_left_x, top_left_y, bottom_right_x, bottom_right_y = tf.unstack(bboxes_corners, axis=-1) | |
bboxes_center = tf.stack( | |
[ | |
(top_left_x + bottom_right_x) / 2, # center x | |
(top_left_y + bottom_right_y) / 2, # center y | |
(bottom_right_x - top_left_x), # width | |
(bottom_right_y - top_left_y), # height | |
], | |
axis=-1, | |
) | |
return bboxes_center | |
def corners_to_center_format(bboxes_corners: TensorType) -> TensorType: | |
""" | |
Converts bounding boxes from corners format to center format. | |
corners format: contains the coodinates for the top-left and bottom-right corners of the box | |
(top_left_x, top_left_y, bottom_right_x, bottom_right_y) | |
center format: contains the coordinate for the center of the box and its the width, height dimensions | |
(center_x, center_y, width, height) | |
""" | |
# Inverse function accepts different input types so implemented here too | |
if is_torch_tensor(bboxes_corners): | |
return _corners_to_center_format_torch(bboxes_corners) | |
elif isinstance(bboxes_corners, np.ndarray): | |
return _corners_to_center_format_numpy(bboxes_corners) | |
elif is_tf_tensor(bboxes_corners): | |
return _corners_to_center_format_tf(bboxes_corners) | |
raise ValueError(f"Unsupported input type {type(bboxes_corners)}") | |
# 2 functions below copied from https://github.com/cocodataset/panopticapi/blob/master/panopticapi/utils.py | |
# Copyright (c) 2018, Alexander Kirillov | |
# All rights reserved. | |
def rgb_to_id(color): | |
""" | |
Converts RGB color to unique ID. | |
""" | |
if isinstance(color, np.ndarray) and len(color.shape) == 3: | |
if color.dtype == np.uint8: | |
color = color.astype(np.int32) | |
return color[:, :, 0] + 256 * color[:, :, 1] + 256 * 256 * color[:, :, 2] | |
return int(color[0] + 256 * color[1] + 256 * 256 * color[2]) | |
def id_to_rgb(id_map): | |
""" | |
Converts unique ID to RGB color. | |
""" | |
if isinstance(id_map, np.ndarray): | |
id_map_copy = id_map.copy() | |
rgb_shape = tuple(list(id_map.shape) + [3]) | |
rgb_map = np.zeros(rgb_shape, dtype=np.uint8) | |
for i in range(3): | |
rgb_map[..., i] = id_map_copy % 256 | |
id_map_copy //= 256 | |
return rgb_map | |
color = [] | |
for _ in range(3): | |
color.append(id_map % 256) | |
id_map //= 256 | |
return color | |
class PaddingMode(ExplicitEnum): | |
""" | |
Enum class for the different padding modes to use when padding images. | |
""" | |
CONSTANT = "constant" | |
REFLECT = "reflect" | |
REPLICATE = "replicate" | |
SYMMETRIC = "symmetric" | |
def pad( | |
image: np.ndarray, | |
padding: Union[int, Tuple[int, int], Iterable[Tuple[int, int]]], | |
mode: PaddingMode = PaddingMode.CONSTANT, | |
constant_values: Union[float, Iterable[float]] = 0.0, | |
data_format: Optional[Union[str, ChannelDimension]] = None, | |
input_data_format: Optional[Union[str, ChannelDimension]] = None, | |
) -> np.ndarray: | |
""" | |
Pads the `image` with the specified (height, width) `padding` and `mode`. | |
Args: | |
image (`np.ndarray`): | |
The image to pad. | |
padding (`int` or `Tuple[int, int]` or `Iterable[Tuple[int, int]]`): | |
Padding to apply to the edges of the height, width axes. Can be one of three formats: | |
- `((before_height, after_height), (before_width, after_width))` unique pad widths for each axis. | |
- `((before, after),)` yields same before and after pad for height and width. | |
- `(pad,)` or int is a shortcut for before = after = pad width for all axes. | |
mode (`PaddingMode`): | |
The padding mode to use. Can be one of: | |
- `"constant"`: pads with a constant value. | |
- `"reflect"`: pads with the reflection of the vector mirrored on the first and last values of the | |
vector along each axis. | |
- `"replicate"`: pads with the replication of the last value on the edge of the array along each axis. | |
- `"symmetric"`: pads with the reflection of the vector mirrored along the edge of the array. | |
constant_values (`float` or `Iterable[float]`, *optional*): | |
The value to use for the padding if `mode` is `"constant"`. | |
data_format (`str` or `ChannelDimension`, *optional*): | |
The channel dimension format for the output image. Can be one of: | |
- `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. | |
- `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. | |
If unset, will use same as the input image. | |
input_data_format (`str` or `ChannelDimension`, *optional*): | |
The channel dimension format for the input image. Can be one of: | |
- `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format. | |
- `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format. | |
If unset, will use the inferred format of the input image. | |
Returns: | |
`np.ndarray`: The padded image. | |
""" | |
if input_data_format is None: | |
input_data_format = infer_channel_dimension_format(image) | |
def _expand_for_data_format(values): | |
""" | |
Convert values to be in the format expected by np.pad based on the data format. | |
""" | |
if isinstance(values, (int, float)): | |
values = ((values, values), (values, values)) | |
elif isinstance(values, tuple) and len(values) == 1: | |
values = ((values[0], values[0]), (values[0], values[0])) | |
elif isinstance(values, tuple) and len(values) == 2 and isinstance(values[0], int): | |
values = (values, values) | |
elif isinstance(values, tuple) and len(values) == 2 and isinstance(values[0], tuple): | |
values = values | |
else: | |
raise ValueError(f"Unsupported format: {values}") | |
# add 0 for channel dimension | |
values = ((0, 0), *values) if input_data_format == ChannelDimension.FIRST else (*values, (0, 0)) | |
# Add additional padding if there's a batch dimension | |
values = (0, *values) if image.ndim == 4 else values | |
return values | |
padding = _expand_for_data_format(padding) | |
if mode == PaddingMode.CONSTANT: | |
constant_values = _expand_for_data_format(constant_values) | |
image = np.pad(image, padding, mode="constant", constant_values=constant_values) | |
elif mode == PaddingMode.REFLECT: | |
image = np.pad(image, padding, mode="reflect") | |
elif mode == PaddingMode.REPLICATE: | |
image = np.pad(image, padding, mode="edge") | |
elif mode == PaddingMode.SYMMETRIC: | |
image = np.pad(image, padding, mode="symmetric") | |
else: | |
raise ValueError(f"Invalid padding mode: {mode}") | |
image = to_channel_dimension_format(image, data_format, input_data_format) if data_format is not None else image | |
return image | |
# TODO (Amy): Accept 1/3/4 channel numpy array as input and return np.array as default | |
def convert_to_rgb(image: ImageInput) -> ImageInput: | |
""" | |
Converts an image to RGB format. Only converts if the image is of type PIL.Image.Image, otherwise returns the image | |
as is. | |
Args: | |
image (Image): | |
The image to convert. | |
""" | |
requires_backends(convert_to_rgb, ["vision"]) | |
if not isinstance(image, PIL.Image.Image): | |
return image | |
image = image.convert("RGB") | |
return image | |
def flip_channel_order( | |
image: np.ndarray, | |
data_format: Optional[ChannelDimension] = None, | |
input_data_format: Optional[Union[str, ChannelDimension]] = None, | |
) -> np.ndarray: | |
""" | |
Flips the channel order of the image. | |
If the image is in RGB format, it will be converted to BGR and vice versa. | |
Args: | |
image (`np.ndarray`): | |
The image to flip. | |
data_format (`ChannelDimension`, *optional*): | |
The channel dimension format for the output image. Can be one of: | |
- `ChannelDimension.FIRST`: image in (num_channels, height, width) format. | |
- `ChannelDimension.LAST`: image in (height, width, num_channels) format. | |
If unset, will use same as the input image. | |
input_data_format (`ChannelDimension`, *optional*): | |
The channel dimension format for the input image. Can be one of: | |
- `ChannelDimension.FIRST`: image in (num_channels, height, width) format. | |
- `ChannelDimension.LAST`: image in (height, width, num_channels) format. | |
If unset, will use the inferred format of the input image. | |
""" | |
input_data_format = infer_channel_dimension_format(image) if input_data_format is None else input_data_format | |
if input_data_format == ChannelDimension.LAST: | |
image = image[..., ::-1] | |
elif input_data_format == ChannelDimension.FIRST: | |
image = image[::-1, ...] | |
else: | |
raise ValueError(f"Unsupported channel dimension: {input_data_format}") | |
if data_format is not None: | |
image = to_channel_dimension_format(image, data_format, input_channel_dim=input_data_format) | |
return image | |