| | """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() |
| |
|
