|
|
"""Read/Write images using OpenCV. |
|
|
|
|
|
Backend Library: `OpenCV <https://opencv.org/>`_ |
|
|
|
|
|
This plugin wraps OpenCV (also known as ``cv2``), a popular image processing |
|
|
library. Currently, it exposes OpenCVs image reading capability (no video or GIF |
|
|
support yet); however, this may be added in future releases. |
|
|
|
|
|
Methods |
|
|
------- |
|
|
.. note:: |
|
|
Check the respective function for a list of supported kwargs and their |
|
|
documentation. |
|
|
|
|
|
.. autosummary:: |
|
|
:toctree: |
|
|
|
|
|
OpenCVPlugin.read |
|
|
OpenCVPlugin.iter |
|
|
OpenCVPlugin.write |
|
|
OpenCVPlugin.properties |
|
|
OpenCVPlugin.metadata |
|
|
|
|
|
Pixel Formats (Colorspaces) |
|
|
--------------------------- |
|
|
|
|
|
OpenCV is known to process images in BGR; however, most of the python ecosystem |
|
|
(in particular matplotlib and other pydata libraries) use the RGB. As such, |
|
|
images are converted to RGB, RGBA, or grayscale (where applicable) by default. |
|
|
|
|
|
""" |
|
|
|
|
|
import warnings |
|
|
from pathlib import Path |
|
|
from typing import Any, Dict, List, Optional, Union |
|
|
|
|
|
import cv2 |
|
|
import numpy as np |
|
|
|
|
|
from ..core import Request |
|
|
from ..core.request import URI_BYTES, InitializationError, IOMode |
|
|
from ..core.v3_plugin_api import ImageProperties, PluginV3 |
|
|
from ..typing import ArrayLike |
|
|
|
|
|
|
|
|
class OpenCVPlugin(PluginV3): |
|
|
def __init__(self, request: Request) -> None: |
|
|
super().__init__(request) |
|
|
|
|
|
self.file_handle = request.get_local_filename() |
|
|
if request._uri_type is URI_BYTES: |
|
|
self.filename = "<bytes>" |
|
|
else: |
|
|
self.filename = request.raw_uri |
|
|
|
|
|
mode = request.mode.io_mode |
|
|
if mode == IOMode.read and not cv2.haveImageReader(self.file_handle): |
|
|
raise InitializationError(f"OpenCV can't read `{self.filename}`.") |
|
|
elif mode == IOMode.write and not cv2.haveImageWriter(self.file_handle): |
|
|
raise InitializationError(f"OpenCV can't write to `{self.filename}`.") |
|
|
|
|
|
def read( |
|
|
self, |
|
|
*, |
|
|
index: int = None, |
|
|
colorspace: Union[int, str] = None, |
|
|
flags: int = cv2.IMREAD_COLOR, |
|
|
) -> np.ndarray: |
|
|
"""Read an image from the ImageResource. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
index : int, Ellipsis |
|
|
If int, read the index-th image from the ImageResource. If ``...``, |
|
|
read all images from the ImageResource and stack them along a new, |
|
|
prepended, batch dimension. If None (default), use ``index=0`` if |
|
|
the image contains exactly one image and ``index=...`` otherwise. |
|
|
colorspace : str, int |
|
|
The colorspace to convert into after loading and before returning |
|
|
the image. If None (default) keep grayscale images as is, convert |
|
|
images with an alpha channel to ``RGBA`` and all other images to |
|
|
``RGB``. If int, interpret ``colorspace`` as one of OpenCVs |
|
|
`conversion flags |
|
|
<https://docs.opencv.org/4.x/d8/d01/group__imgproc__color__conversions.html>`_ |
|
|
and use it for conversion. If str, convert the image into the given |
|
|
colorspace. Possible string values are: ``"RGB"``, ``"BGR"``, |
|
|
``"RGBA"``, ``"BGRA"``, ``"GRAY"``, ``"HSV"``, or ``"LAB"``. |
|
|
flags : int |
|
|
The OpenCV flag(s) to pass to the reader. Refer to the `OpenCV docs |
|
|
<https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56>`_ |
|
|
for details. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
ndimage : np.ndarray |
|
|
The decoded image as a numpy array. |
|
|
|
|
|
""" |
|
|
|
|
|
if index is None: |
|
|
n_images = cv2.imcount(self.file_handle, flags) |
|
|
index = 0 if n_images == 1 else ... |
|
|
|
|
|
if index is ...: |
|
|
retval, img = cv2.imreadmulti(self.file_handle, flags=flags) |
|
|
is_batch = True |
|
|
else: |
|
|
retval, img = cv2.imreadmulti(self.file_handle, index, 1, flags=flags) |
|
|
is_batch = False |
|
|
|
|
|
if retval is False: |
|
|
raise ValueError(f"Could not read index `{index}` from `{self.filename}`.") |
|
|
|
|
|
if img[0].ndim == 2: |
|
|
in_colorspace = "GRAY" |
|
|
out_colorspace = colorspace or "GRAY" |
|
|
elif img[0].shape[-1] == 4: |
|
|
in_colorspace = "BGRA" |
|
|
out_colorspace = colorspace or "RGBA" |
|
|
else: |
|
|
in_colorspace = "BGR" |
|
|
out_colorspace = colorspace or "RGB" |
|
|
|
|
|
if isinstance(colorspace, int): |
|
|
cvt_space = colorspace |
|
|
elif in_colorspace == out_colorspace.upper(): |
|
|
cvt_space = None |
|
|
else: |
|
|
out_colorspace = out_colorspace.upper() |
|
|
cvt_space = getattr(cv2, f"COLOR_{in_colorspace}2{out_colorspace}") |
|
|
|
|
|
if cvt_space is not None: |
|
|
img = np.stack([cv2.cvtColor(x, cvt_space) for x in img]) |
|
|
else: |
|
|
img = np.stack(img) |
|
|
|
|
|
return img if is_batch else img[0] |
|
|
|
|
|
def iter( |
|
|
self, |
|
|
colorspace: Union[int, str] = None, |
|
|
flags: int = cv2.IMREAD_COLOR, |
|
|
) -> np.ndarray: |
|
|
"""Yield images from the ImageResource. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
colorspace : str, int |
|
|
The colorspace to convert into after loading and before returning |
|
|
the image. If None (default) keep grayscale images as is, convert |
|
|
images with an alpha channel to ``RGBA`` and all other images to |
|
|
``RGB``. If int, interpret ``colorspace`` as one of OpenCVs |
|
|
`conversion flags |
|
|
<https://docs.opencv.org/4.x/d8/d01/group__imgproc__color__conversions.html>`_ |
|
|
and use it for conversion. If str, convert the image into the given |
|
|
colorspace. Possible string values are: ``"RGB"``, ``"BGR"``, |
|
|
``"RGBA"``, ``"BGRA"``, ``"GRAY"``, ``"HSV"``, or ``"LAB"``. |
|
|
flags : int |
|
|
The OpenCV flag(s) to pass to the reader. Refer to the `OpenCV docs |
|
|
<https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56>`_ |
|
|
for details. |
|
|
|
|
|
Yields |
|
|
------ |
|
|
ndimage : np.ndarray |
|
|
The decoded image as a numpy array. |
|
|
|
|
|
""" |
|
|
for idx in range(cv2.imcount(self.file_handle)): |
|
|
yield self.read(index=idx, flags=flags, colorspace=colorspace) |
|
|
|
|
|
def write( |
|
|
self, |
|
|
ndimage: Union[ArrayLike, List[ArrayLike]], |
|
|
is_batch: bool = False, |
|
|
params: List[int] = None, |
|
|
) -> Optional[bytes]: |
|
|
"""Save an ndimage in the ImageResource. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
ndimage : ArrayLike, List[ArrayLike] |
|
|
The image data that will be written to the file. It is either a |
|
|
single image, a batch of images, or a list of images. |
|
|
is_batch : bool |
|
|
If True, the provided ndimage is a batch of images. If False (default), the |
|
|
provided ndimage is a single image. If the provided ndimage is a list of images, |
|
|
this parameter has no effect. |
|
|
params : List[int] |
|
|
A list of parameters that will be passed to OpenCVs imwrite or |
|
|
imwritemulti functions. Possible values are documented in the |
|
|
`OpenCV documentation |
|
|
<https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#gabbc7ef1aa2edfaa87772f1202d67e0ce>`_. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
encoded_image : bytes, None |
|
|
If the ImageResource is ``"<bytes>"`` the call to write returns the |
|
|
encoded image as a bytes string. Otherwise it returns None. |
|
|
|
|
|
""" |
|
|
|
|
|
if isinstance(ndimage, list): |
|
|
ndimage = np.stack(ndimage, axis=0) |
|
|
elif not is_batch: |
|
|
ndimage = ndimage[None, ...] |
|
|
|
|
|
if ndimage[0].ndim == 2: |
|
|
n_channels = 1 |
|
|
else: |
|
|
n_channels = ndimage[0].shape[-1] |
|
|
|
|
|
if n_channels == 1: |
|
|
ndimage_cv2 = [x for x in ndimage] |
|
|
elif n_channels == 4: |
|
|
ndimage_cv2 = [cv2.cvtColor(x, cv2.COLOR_RGBA2BGRA) for x in ndimage] |
|
|
else: |
|
|
ndimage_cv2 = [cv2.cvtColor(x, cv2.COLOR_RGB2BGR) for x in ndimage] |
|
|
|
|
|
retval = cv2.imwritemulti(self.file_handle, ndimage_cv2, params) |
|
|
|
|
|
if retval is False: |
|
|
|
|
|
|
|
|
raise IOError("OpenCV failed to write.") |
|
|
|
|
|
if self.request._uri_type == URI_BYTES: |
|
|
return Path(self.file_handle).read_bytes() |
|
|
|
|
|
def properties( |
|
|
self, |
|
|
index: int = None, |
|
|
colorspace: Union[int, str] = None, |
|
|
flags: int = cv2.IMREAD_COLOR, |
|
|
) -> ImageProperties: |
|
|
"""Standardized image metadata. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
index : int, Ellipsis |
|
|
If int, get the properties of the index-th image in the |
|
|
ImageResource. If ``...``, get the properties of the image stack |
|
|
that contains all images. If None (default), use ``index=0`` if the |
|
|
image contains exactly one image and ``index=...`` otherwise. |
|
|
colorspace : str, int |
|
|
The colorspace to convert into after loading and before returning |
|
|
the image. If None (default) keep grayscale images as is, convert |
|
|
images with an alpha channel to ``RGBA`` and all other images to |
|
|
``RGB``. If int, interpret ``colorspace`` as one of OpenCVs |
|
|
`conversion flags |
|
|
<https://docs.opencv.org/4.x/d8/d01/group__imgproc__color__conversions.html>`_ |
|
|
and use it for conversion. If str, convert the image into the given |
|
|
colorspace. Possible string values are: ``"RGB"``, ``"BGR"``, |
|
|
``"RGBA"``, ``"BGRA"``, ``"GRAY"``, ``"HSV"``, or ``"LAB"``. |
|
|
flags : int |
|
|
The OpenCV flag(s) to pass to the reader. Refer to the `OpenCV docs |
|
|
<https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56>`_ |
|
|
for details. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
props : ImageProperties |
|
|
A dataclass filled with standardized image metadata. |
|
|
|
|
|
Notes |
|
|
----- |
|
|
Reading properties with OpenCV involves decoding pixel data, because |
|
|
OpenCV doesn't provide a direct way to access metadata. |
|
|
|
|
|
""" |
|
|
|
|
|
if index is None: |
|
|
n_images = cv2.imcount(self.file_handle, flags) |
|
|
is_batch = n_images > 1 |
|
|
elif index is Ellipsis: |
|
|
n_images = cv2.imcount(self.file_handle, flags) |
|
|
is_batch = True |
|
|
else: |
|
|
is_batch = False |
|
|
|
|
|
|
|
|
if is_batch: |
|
|
img = self.read(index=0, flags=flags, colorspace=colorspace) |
|
|
return ImageProperties( |
|
|
shape=(n_images, *img.shape), |
|
|
dtype=img.dtype, |
|
|
n_images=n_images, |
|
|
is_batch=True, |
|
|
) |
|
|
|
|
|
img = self.read(index=index, flags=flags, colorspace=colorspace) |
|
|
return ImageProperties(shape=img.shape, dtype=img.dtype, is_batch=False) |
|
|
|
|
|
def metadata( |
|
|
self, index: int = None, exclude_applied: bool = True |
|
|
) -> Dict[str, Any]: |
|
|
"""Format-specific metadata. |
|
|
|
|
|
.. warning:: |
|
|
OpenCV does not support reading metadata. When called, this function |
|
|
will raise a ``NotImplementedError``. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
index : int |
|
|
This parameter has no effect. |
|
|
exclude_applied : bool |
|
|
This parameter has no effect. |
|
|
|
|
|
""" |
|
|
|
|
|
warnings.warn("OpenCV does not support reading metadata.", UserWarning) |
|
|
return dict() |
|
|
|
