Reading HEIC Images in Python

When you want to read an image, you might use the imread function from OpenCV.

Unfortunately, this function is not universal, and you may encounter some problems.

Basic Usage

The basic usage of the imread function is straightforward; you just need to pass the path to the image:

import cv2

image = cv2.imread('path/to/image.jpg')

You can use common image formats such as BMP, JPG, PNG, TIF, and others.

Limitation 1: HEIC Format

Images captured on iOS devices are typically in HEIC format, which is not supported in OpenCV. If you try to use the imread function to read HEIC format images, you will get a None return value.

To address this issue, we need to use the pyheif package to read HEIC format images and then convert them into numpy.ndarray variables.

First, install the necessary packages:

sudo apt install libheif-dev
pip install pyheif

Then, write a simple function:

import cv2
import pyheif
import numpy as np

def read_heic_to_numpy(file_path: str):
    heif_file = pyheif.read(file_path)
    data = heif_file.data
    if heif_file.mode == "RGB":
        numpy_array = np.frombuffer(data, dtype=np.uint8).reshape(
            heif_file.size[1], heif_file.size[0], 3)
    elif heif_file.mode == "RGBA":
        numpy_array = np.frombuffer(data, dtype=np.uint8).reshape(
            heif_file.size[1], heif_file.size[0], 4)
    else:
        raise ValueError("Unsupported HEIC color mode")
    return numpy_array


img = read_heic_to_numpy('path/to/image.heic')
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)

Limitation 2: Slow JPG Reading

In some cases, the imread function's performance in reading JPG format images can be slow. This is because OpenCV uses the libjpeg library to read JPG format images, and libjpeg itself is not very efficient.

Here, we introduce the TurboJPEG package, an alternative to libjpeg with better performance. We can use TurboJPEG to accelerate the reading of JPG format images.

Similarly, install the necessary packages:

sudo apt install libturbojpeg exiftool
pip install PyTurboJPEG

Then, let's optimize it a bit:

Generally, this can speed up the process by about 2-3 times.

import cv2
import piexif
from enum import IntEnum
from pathlib import Path
from turbojpeg import TurboJPEG


jpeg = TurboJPEG()


class ROTATE(IntEnum):
    ROTATE_90 = cv2.ROTATE_90_CLOCKWISE
    ROTATE_180 = cv2.ROTATE_180
    ROTATE_270 = cv2.ROTATE_90_COUNTERCLOCKWISE


def imrotate90(img, rotate_code: ROTATE) -> np.ndarray:
    return cv2.rotate(img.copy(), rotate_code)


def get_orientation_code(stream: Union[str, Path, bytes]):
    code = None
    try:
        exif_dict = piexif.load(stream)
        if piexif.ImageIFD.Orientation in exif_dict["0th"]:
            orientation = exif_dict["0th"][piexif.ImageIFD.Orientation]
            if orientation == 3:
                code = ROTATE.ROTATE_180
            elif orientation == 6:
                code = ROTATE.ROTATE_90
            elif orientation == 8:
                code = ROTATE.ROTATE_270
    finally:
        return code


def jpgdecode(byte_: bytes) -> Union[np.ndarray, None]:
    try:
        bgr_array = jpeg.decode(byte_)
        code = get_orientation_code(byte_)
        bgr_array = imrotate90(
            bgr_array, code) if code is not None else bgr_array
    except:
        bgr_array = None

    return bgr_array


def jpgread(img_file: Union[str, Path]) -> Union[np.ndarray, None]:
    with open(str(img_file), 'rb') as f:
        binary_img = f.read()
        bgr_array = jpgdecode(binary_img)

    return bgr_array

img = jpgread('path/to/image.jpg')

This way, reading JPG format images can be accelerated.

Conclusion

What if we want this program to be more intelligent, choosing a suitable way to load images on its own?

We can write a function to select the appropriate loading method based on the image's format:

def imread(
    path: Union[str, Path],
    color_base: str = 'BGR',
    verbose: bool = False
) -> Union[np.ndarray, None]:

    if not Path(path).exists():
        raise FileExistsError(f'{path} can not be found.')

    if Path(path).suffix.lower() == '.heic':
        img = read_heic_to_numpy(str(path))
        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
    else:
        img = jpgread(path)
        img = cv2.imread(str(path)) if img is None else img

    if img is None:
        if verbose:
            warnings.warn("Got a None type image.")
        return

    if color_base != 'BGR':
        img = imcvtcolor(img, cvt_mode=f'BGR2{color_base}')

    return img

For detailed code, you can refer to: imread.py