OpenCV provides two complementary utilities for converting between raw byte streams and image matrices:

• cv2.imdecode: turns a byte buffer (e.g., data received over a network) into a decoded image array.
• cv2.imencode: compresses an image array into a specific file format and returns the encoded bytes in memory.

These functions are useful for network transmission, in-memory caching, and custom storage of image data.

cv2.imdecode: reconstructing images from bytes

Typical use case: fetch image bytes from a remote source and convert them into a NumPy image for further processing.

# Python 3
import urllib.request
import numpy as np
import cv2

# Download an image as raw bytes
url = 'https://upload.wikimedia.org/wikipedia/commons/4/47/PNG_transparency_demonstration_1.png'
with urllib.request.urlopen(url, timeout=10) as resp:
    payload = resp.read()  # bytes

# Convert bytes to a 1D uint8 array
buffer = np.frombuffer(payload, dtype=np.uint8)

# Decode into a BGR image (as returned by OpenCV)
img = cv2.imdecode(buffer, flags=cv2.IMREAD_COLOR)

cv2.imshow('Decoded from URL', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

Notes:

• cv2.imdecode expects a 1D uint8 array of compressed image data.
• The flags parameter controls how the image is decoded (e.g., cv2.IMREAD_COLOR, cv2.IMREAD_GRAYSCALE).

cv2.imencode: compressing an image into memory

Typical use case: compress an image to a chosen format (e.g., JPEG/PNG) without writing directly to disk, then optionally save or transmit the bytes.

import numpy as np
import cv2

# Load an image from disk
img = cv2.imread('image.jpg')  # replace with your path

# Encode to JPEG. You can adjust quality using IMWRITE_JPEG_QUALITY
ok, encoded = cv2.imencode('.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 90])
if not ok:
    raise RuntimeError('Encoding failed')

# Convert the encoded ndarray to raw bytes
blob = encoded.tobytes()

# Persist the encoded bytes (binary mode)
with open('image_encoded.bin', 'wb') as f:
    f.write(blob)

Notes:

• The extension passed to cv2.imencode (e.g., '.jpg', '.png') determines the codec and compression.
• The second return value is a NumPy array of dtype uint8 containing the compressed data.

Round-trip: encode to bytes, save, read back, and decode

This example shows how to store a compressed rperesentation and latter reconstruct the image.

import numpy as np
import cv2

# Read a source image
src = cv2.imread('image.jpg')

# Encode to PNG for a lossless round-trip
success, out_buf = cv2.imencode('.png', src)
if not success:
    raise RuntimeError('Encoding failed')

# Write the compressed payload to disk
with open('image_payload.dat', 'wb') as fo:
    fo.write(out_buf.tobytes())

# Read the payload and decode it back to an image
with open('image_payload.dat', 'rb') as fi:
    data = fi.read()

byte_array = np.frombuffer(data, dtype=np.uint8)
restored = cv2.imdecode(byte_array, cv2.IMREAD_COLOR)

cv2.imshow('Restored', restored)
cv2.waitKey(0)
cv2.destroyAllWindows()

Alternative decoding approach using bytearray

import numpy as np
import cv2

with open('image_payload.dat', 'rb') as fi:
    raw = fi.read()

# Construct a uint8 array via bytearray (behaviorally similar to frombuffer here)
arr = np.asarray(bytearray(raw), dtype=np.uint8)
img_decoded = cv2.imdecode(arr, cv2.IMREAD_COLOR)

cv2.imshow('Decoded (bytearray variant)', img_decoded)
cv2.waitKey(0)
cv2.destroyAllWindows()

Key points:

• Use binary file modes ('rb' and 'wb') when working with compressed bytes.
• np.frombuffer is efficient for turning a bytes object into a uint8 vector.
• cv2.imencode/cv2.imdecode are ideal for network workflows and memory-only image processing.