Color Space Conversions

Learn how to convert between different color spaces and apply thresholding techniques

This guide covers color space conversions between BGR, RGB, HSV, grayscale, and other formats, along with thresholding techniques for image segmentation.

Overview

Color spaces represent colors in different ways for various purposes:

• BGR/RGB: Standard color representation for displays
• HSV: Hue, Saturation, Value - intuitive for color filtering
• Grayscale: Single channel intensity values
• LAB: Perceptually uniform color space
• YCrCb: Luminance and chrominance separation

BGR to RGB Conversion

OpenCV reads images in BGR format by default, but many libraries expect RGB.

Python

import cv2 as cv
import matplotlib.pyplot as plt

# Read image (loaded in BGR format)
img_bgr = cv.imread("image.jpg")

# Convert BGR to RGB
img_rgb = cv.cvtColor(img_bgr, cv.COLOR_BGR2RGB)

# Display using matplotlib (expects RGB)
plt.imshow(img_rgb)
plt.title("RGB Image")
plt.axis('off')
plt.show()

# Display using OpenCV (expects BGR)
cv.imshow("BGR Image", img_bgr)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

// Read image (loaded in BGR format)
Mat img_bgr = imread("image.jpg");

// Convert BGR to RGB
Mat img_rgb;
cvtColor(img_bgr, img_rgb, COLOR_BGR2RGB);

// Display (OpenCV expects BGR)
imshow("BGR Image", img_bgr);
waitKey(0);

OpenCV uses BGR format by default for historical reasons related to early camera standards. Always convert to RGB when interfacing with other libraries like Matplotlib, PIL, or TensorFlow.

BGR to Grayscale Conversion

Convert color images to grayscale for simplified processing.

Python

import cv2 as cv

# Read color image
img = cv.imread("image.jpg")

# Convert to grayscale
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

cv.imshow("Original", img)
cv.imshow("Grayscale", gray)
cv.waitKey(0)
cv.destroyAllWindows()

C++

#include <opencv2/opencv.hpp>
using namespace cv;

// Read color image
Mat img = imread("image.jpg");

// Convert to grayscale
Mat gray;
cvtColor(img, gray, COLOR_BGR2GRAY);

imshow("Original", img);
imshow("Grayscale", gray);
waitKey(0);

You can also load images directly in grayscale using imread("image.jpg", IMREAD_GRAYSCALE) to skip the conversion step.

BGR to HSV Conversion

HSV (Hue, Saturation, Value) is ideal for color-based object detection and filtering.

Python

import cv2 as cv
import numpy as np

# Read image
img = cv.imread("image.jpg")

# Convert BGR to HSV
hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)

# Split into channels
h, s, v = cv.split(hsv)

cv.imshow("Original", img)
cv.imshow("Hue", h)
cv.imshow("Saturation", s)
cv.imshow("Value", v)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;

// Read image
Mat img = imread("image.jpg");

// Convert BGR to HSV
Mat hsv;
cvtColor(img, hsv, COLOR_BGR2HSV);

// Split into channels
vector<Mat> channels;
split(hsv, channels);

imshow("Original", img);
imshow("Hue", channels[0]);
imshow("Saturation", channels[1]);
imshow("Value", channels[2]);
waitKey(0);

Color Range Detection with HSV

Detect specific colors by defining HSV ranges.

Python

import cv2 as cv
import numpy as np

# Read image
frame = cv.imread("image.jpg")

# Convert to HSV
frame_HSV = cv.cvtColor(frame, cv.COLOR_BGR2HSV)

# Define range for blue color in HSV
low_H = 100
low_S = 50
low_V = 50
high_H = 130
high_S = 255
high_V = 255

# Create mask for blue color
mask = cv.inRange(frame_HSV, (low_H, low_S, low_V), (high_H, high_S, high_V))

# Apply mask to original image
result = cv.bitwise_and(frame, frame, mask=mask)

cv.imshow("Original", frame)
cv.imshow("Mask", mask)
cv.imshow("Result", result)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

// Read image
Mat frame = imread("image.jpg");

// Convert to HSV
Mat frame_HSV;
cvtColor(frame, frame_HSV, COLOR_BGR2HSV);

// Define range for blue color in HSV
int low_H = 100, low_S = 50, low_V = 50;
int high_H = 130, high_S = 255, high_V = 255;

// Create mask for blue color
Mat mask;
inRange(frame_HSV, Scalar(low_H, low_S, low_V), 
        Scalar(high_H, high_S, high_V), mask);

// Apply mask to original image
Mat result;
bitwise_and(frame, frame, result, mask);

imshow("Original", frame);
imshow("Mask", mask);
imshow("Result", result);
waitKey(0);

Common HSV Color Ranges

Color	Hue Range (H)	Saturation (S)	Value (V)
Red	0-10, 170-180	50-255	50-255
Orange	10-25	50-255	50-255
Yellow	25-35	50-255	50-255
Green	35-85	50-255	50-255
Blue	100-130	50-255	50-255
Purple	130-160	50-255	50-255

In OpenCV, Hue values range from 0-179 (not 0-359) to fit in a single byte. Adjust your ranges accordingly.

Thresholding

Thresholding converts grayscale images to binary images by applying a threshold value.

Basic Thresholding

Python

import cv2 as cv

# Read image in grayscale
src = cv.imread("image.jpg")
src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

# Apply different threshold types
threshold_value = 127
max_value = 255

# Binary threshold
_, binary = cv.threshold(src_gray, threshold_value, max_value, cv.THRESH_BINARY)

# Binary inverted threshold
_, binary_inv = cv.threshold(src_gray, threshold_value, max_value, cv.THRESH_BINARY_INV)

# Truncate threshold
_, truncate = cv.threshold(src_gray, threshold_value, max_value, cv.THRESH_TRUNC)

# To zero threshold
_, to_zero = cv.threshold(src_gray, threshold_value, max_value, cv.THRESH_TOZERO)

# To zero inverted threshold
_, to_zero_inv = cv.threshold(src_gray, threshold_value, max_value, cv.THRESH_TOZERO_INV)

cv.imshow("Original", src_gray)
cv.imshow("Binary", binary)
cv.imshow("Binary Inverted", binary_inv)
cv.imshow("Truncate", truncate)
cv.imshow("To Zero", to_zero)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

// Read image in grayscale
Mat src = imread("image.jpg");
Mat src_gray;
cvtColor(src, src_gray, COLOR_BGR2GRAY);

// Apply different threshold types
int threshold_value = 127;
int max_value = 255;

Mat binary, binary_inv, truncate, to_zero, to_zero_inv;

// Binary threshold
threshold(src_gray, binary, threshold_value, max_value, THRESH_BINARY);

// Binary inverted threshold
threshold(src_gray, binary_inv, threshold_value, max_value, THRESH_BINARY_INV);

// Truncate threshold
threshold(src_gray, truncate, threshold_value, max_value, THRESH_TRUNC);

// To zero threshold
threshold(src_gray, to_zero, threshold_value, max_value, THRESH_TOZERO);

// To zero inverted threshold
threshold(src_gray, to_zero_inv, threshold_value, max_value, THRESH_TOZERO_INV);

imshow("Original", src_gray);
imshow("Binary", binary);
imshow("Binary Inverted", binary_inv);
waitKey(0);

Adaptive Thresholding

Adaptive thresholding calculates different thresholds for different regions, useful for varying lighting conditions.

Python

import cv2 as cv

# Read image in grayscale
img = cv.imread("image.jpg")
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

# Global threshold
_, global_thresh = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)

# Adaptive threshold (mean)
adaptive_mean = cv.adaptiveThreshold(gray, 255, 
                                      cv.ADAPTIVE_THRESH_MEAN_C,
                                      cv.THRESH_BINARY, 11, 2)

# Adaptive threshold (gaussian)
adaptive_gaussian = cv.adaptiveThreshold(gray, 255,
                                          cv.ADAPTIVE_THRESH_GAUSSIAN_C,
                                          cv.THRESH_BINARY, 11, 2)

cv.imshow("Original", gray)
cv.imshow("Global Threshold", global_thresh)
cv.imshow("Adaptive Mean", adaptive_mean)
cv.imshow("Adaptive Gaussian", adaptive_gaussian)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

// Read image in grayscale
Mat img = imread("image.jpg");
Mat gray;
cvtColor(img, gray, COLOR_BGR2GRAY);

Mat global_thresh, adaptive_mean, adaptive_gaussian;

// Global threshold
threshold(gray, global_thresh, 127, 255, THRESH_BINARY);

// Adaptive threshold (mean)
adaptiveThreshold(gray, adaptive_mean, 255,
                  ADAPTIVE_THRESH_MEAN_C,
                  THRESH_BINARY, 11, 2);

// Adaptive threshold (gaussian)
adaptiveThreshold(gray, adaptive_gaussian, 255,
                  ADAPTIVE_THRESH_GAUSSIAN_C,
                  THRESH_BINARY, 11, 2);

imshow("Original", gray);
imshow("Global Threshold", global_thresh);
imshow("Adaptive Mean", adaptive_mean);
imshow("Adaptive Gaussian", adaptive_gaussian);
waitKey(0);

Other Color Space Conversions

Python

import cv2 as cv

img = cv.imread("image.jpg")

# BGR to LAB
lab = cv.cvtColor(img, cv.COLOR_BGR2LAB)

# BGR to YCrCb
ycrcb = cv.cvtColor(img, cv.COLOR_BGR2YCrCb)

# BGR to XYZ
xyz = cv.cvtColor(img, cv.COLOR_BGR2XYZ)

# BGR to HLS
hls = cv.cvtColor(img, cv.COLOR_BGR2HLS)

# HSV back to BGR
hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)
bgr_from_hsv = cv.cvtColor(hsv, cv.COLOR_HSV2BGR)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

Mat img = imread("image.jpg");
Mat lab, ycrcb, xyz, hls, hsv, bgr_from_hsv;

// BGR to LAB
cvtColor(img, lab, COLOR_BGR2LAB);

// BGR to YCrCb
cvtColor(img, ycrcb, COLOR_BGR2YCrCb);

// BGR to XYZ
cvtColor(img, xyz, COLOR_BGR2XYZ);

// BGR to HLS
cvtColor(img, hls, COLOR_BGR2HLS);

// HSV back to BGR
cvtColor(img, hsv, COLOR_BGR2HSV);
cvtColor(hsv, bgr_from_hsv, COLOR_HSV2BGR);

Key Functions

Function	Description
cvtColor()	Convert image between color spaces
split()	Split multi-channel image into separate channels
merge()	Merge separate channels into multi-channel image
inRange()	Create binary mask for pixels within specified range
threshold()	Apply global threshold to grayscale image
adaptiveThreshold()	Apply adaptive threshold for varying lighting

Common Color Space Codes

Conversion	Code
BGR to RGB	COLOR_BGR2RGB
BGR to Gray	COLOR_BGR2GRAY
BGR to HSV	COLOR_BGR2HSV
BGR to LAB	COLOR_BGR2LAB
HSV to BGR	COLOR_HSV2BGR
Gray to BGR	COLOR_GRAY2BGR

For color-based object detection, HSV color space is generally more robust than BGR/RGB because it separates color information (Hue) from lighting conditions (Value).