使用 OpenCV 自动调整图像亮度

Question

我想在 OpenCV 中将图像的亮度调整为某个值。 例如，考虑这个图像：

我用以下方法计算亮度：

import cv2
img = cv2.imread(filepath)
cols, rows = img.shape
brightness = numpy.sum(img) / (255 * cols * rows)

我的平均亮度为 35%。 例如，要使其达到 66%，我会这样做：

minimum_brightness = 0.66
alpha = brightness / minimum_brightness
bright_img = cv2.convertScaleAbs(img, alpha = alpha, beta = 255 * (1 - alpha))

我得到的图像似乎有 50% 的透明度面纱：

我可以通过仅使用偏差来避免这种影响：

bright_img = cv2.convertScaleAbs(img, alpha = 1, beta = 128)

图像似乎也有面纱：

如果我手动完成，例如在 Photoshop 中将亮度调整为 150，结果似乎没问题：

但是，这不是自动的，也不会给出目标亮度。

我可以通过伽马校正和/或直方图均衡来实现，以获得更自然的结果，但除了反复试验之外，我没有看到获得目标亮度的简单方法。

有没有人成功地根据目标自动调整亮度？

更新

卡纳特建议：

bright_img = cv2.convertScaleAbs(img, alpha = 1, beta = 255 * (minimum_brightness - brightness))

结果更好，但仍然有面纱：

Yves Daoust 建议保持beta = 0 ，所以我调整了alpha = minimum_brightness / brightness Brightness 以获得目标亮度：

ratio = brightness / minimum_brightness
if ratio >= 1:
    print("Image already bright enough")
    return img

# Otherwise, adjust brightness to get the target brightness
return cv2.convertScaleAbs(img, alpha = 1 / ratio, beta = 0)

结果很好：

Answer 1

您可以尝试使用带有直方图剪裁的对比度优化来自动调整亮度。 您可以通过增加直方图剪辑百分比 ( clip_hist_percent ) 来增加目标亮度。 这是 25% 剪裁的结果

Alpha 和 Beta 是自动计算的

阿尔法 3.072289156626506

测试版 -144.3975903614458

这是剪辑的可视化。 蓝色（原始）、橙色（自动调整后）。

裁剪率为 35% 的结果

阿尔法 3.8059701492537314

测试版 -201.71641791044777

其他方法可以使用Histogram Equalization 或 CLAHE 。

import cv2
import numpy as np
# from matplotlib import pyplot as plt

# Automatic brightness and contrast optimization with optional histogram clipping
def automatic_brightness_and_contrast(image, clip_hist_percent=25):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Calculate grayscale histogram
    hist = cv2.calcHist([gray],[0],None,[256],[0,256])
    hist_size = len(hist)

    # Calculate cumulative distribution from the histogram
    accumulator = []
    accumulator.append(float(hist[0]))
    for index in range(1, hist_size):
        accumulator.append(accumulator[index -1] + float(hist[index]))

    # Locate points to clip
    maximum = accumulator[-1]
    clip_hist_percent *= (maximum/100.0)
    clip_hist_percent /= 2.0

    # Locate left cut
    minimum_gray = 0
    while accumulator[minimum_gray] < clip_hist_percent:
        minimum_gray += 1

    # Locate right cut
    maximum_gray = hist_size -1
    while accumulator[maximum_gray] >= (maximum - clip_hist_percent):
        maximum_gray -= 1

    # Calculate alpha and beta values
    alpha = 255 / (maximum_gray - minimum_gray)
    beta = -minimum_gray * alpha

    '''
    # Calculate new histogram with desired range and show histogram 
    new_hist = cv2.calcHist([gray],[0],None,[256],[minimum_gray,maximum_gray])
    plt.plot(hist)
    plt.plot(new_hist)
    plt.xlim([0,256])
    plt.show()
    '''

    auto_result = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
    return (auto_result, alpha, beta)

image = cv2.imread('1.png')
auto_result, alpha, beta = automatic_brightness_and_contrast(image)
print('alpha', alpha)
print('beta', beta)
cv2.imshow('auto_result', auto_result)
cv2.imwrite('auto_result.png', auto_result)
cv2.imshow('image', image)
cv2.waitKey()

另一种版本是使用饱和度算法而不是使用 OpenCV 的cv2.convertScaleAbs为图像添加偏差和增益。 内置方法不采用绝对值，这会导致无意义的结果（例如，在 alpha = 3 和 beta = -210 的情况下，44 处的像素在 OpenCV 中变为 78，而实际上它应该变为 0）。

import cv2
import numpy as np
# from matplotlib import pyplot as plt

def convertScale(img, alpha, beta):
    """Add bias and gain to an image with saturation arithmetics. Unlike
    cv2.convertScaleAbs, it does not take an absolute value, which would lead to
    nonsensical results (e.g., a pixel at 44 with alpha = 3 and beta = -210
    becomes 78 with OpenCV, when in fact it should become 0).
    """

    new_img = img * alpha + beta
    new_img[new_img < 0] = 0
    new_img[new_img > 255] = 255
    return new_img.astype(np.uint8)

# Automatic brightness and contrast optimization with optional histogram clipping
def automatic_brightness_and_contrast(image, clip_hist_percent=25):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Calculate grayscale histogram
    hist = cv2.calcHist([gray],[0],None,[256],[0,256])
    hist_size = len(hist)

    # Calculate cumulative distribution from the histogram
    accumulator = []
    accumulator.append(float(hist[0]))
    for index in range(1, hist_size):
        accumulator.append(accumulator[index -1] + float(hist[index]))

    # Locate points to clip
    maximum = accumulator[-1]
    clip_hist_percent *= (maximum/100.0)
    clip_hist_percent /= 2.0

    # Locate left cut
    minimum_gray = 0
    while accumulator[minimum_gray] < clip_hist_percent:
        minimum_gray += 1

    # Locate right cut
    maximum_gray = hist_size -1
    while accumulator[maximum_gray] >= (maximum - clip_hist_percent):
        maximum_gray -= 1

    # Calculate alpha and beta values
    alpha = 255 / (maximum_gray - minimum_gray)
    beta = -minimum_gray * alpha

    '''
    # Calculate new histogram with desired range and show histogram 
    new_hist = cv2.calcHist([gray],[0],None,[256],[minimum_gray,maximum_gray])
    plt.plot(hist)
    plt.plot(new_hist)
    plt.xlim([0,256])
    plt.show()
    '''

    auto_result = convertScale(image, alpha=alpha, beta=beta)
    return (auto_result, alpha, beta)

image = cv2.imread('1.jpg')
auto_result, alpha, beta = automatic_brightness_and_contrast(image)
print('alpha', alpha)
print('beta', beta)
cv2.imshow('auto_result', auto_result)
cv2.imwrite('auto_result.png', auto_result)
cv2.imshow('image', image)
cv2.waitKey()

Answer 2

您需要修改对比度和亮度。

我不使用 OpenCV，但这是我为 Imagemagick 构建的（Unix）bash 脚本的解决方案。 请注意， mean 控制亮度， std 控制对比度。

该脚本最初旨在调整一张图像以匹配另一张图像的颜色/亮度/对比度。 匹配使用每个图像的平均值和标准偏差，根据等式：(I2-Mean2)/Std2 = (I1-Mean1)/Std1。 该方程表示归一化强度，由于除以标准偏差，它具有零均值和大致相同的值范围。 我们求解这个方程，根据 I2 = A x I1 + B 形成 I1 和 I2 之间的线性变换，其中 A=(Std2/Std1) 是斜率或增益，B=(Mean2 - A x Mean1) 是截距偏见。 如果没有提供第二张图像并且提供了（一组）均值和标准差，则第一个文件将与提供的均值和标准差匹配。 斜率或增益与对比度相关，截距或偏差与亮度相关。

输入：

matchimage -c rgb -m 0.6 -s 0.25 bunny.png result1.png

或者稍微对比一下：

matchimage -c rgb -m 0.6 -s 0.35 bunny.png result2.png

参数标准化为 0 到 1 范围。 所以均值=0.6 相当于 60%。 我认为 66% 可能太亮了，但您可以根据需要更改这些值。

在这种情况下，由于您的图像大部分是灰度的，因此我使用色彩空间 RGB 进行处理。 处理可以在其他几种颜色空间中完成。

有一个类似的Python脚本在这里，刚刚匹配一个图像到另一个，但在Lab色彩空间这样做。 但是，将其更改为将一个图像与一组均值和标准参数相匹配应该很容易。

（我的脚本可以在这里找到）

Answer 3

一种解决方案是调整图像的伽马。 在下面的代码中，我首先将图像饱和到范围顶部和底部的某个百分位数，然后调整伽马校正，直到达到所需的亮度。

import cv2
import numpy as np

def saturate(img, percentile):
    """Changes the scale of the image so that half of percentile at the low range
    becomes 0, half of percentile at the top range becomes 255.
    """

    if 2 != len(img.shape):
        raise ValueError("Expected an image with only one channel")

    # copy values
    channel = img[:, :].copy()
    flat = channel.ravel()

    # copy values and sort them
    sorted_values = np.sort(flat)

    # find points to clip
    max_index = len(sorted_values) - 1
    half_percent = percentile / 200
    low_value = sorted_values[math.floor(max_index * half_percent)]
    high_value = sorted_values[math.ceil(max_index * (1 - half_percent))]

    # saturate
    channel[channel < low_value] = low_value
    channel[channel > high_value] = high_value

    # scale the channel
    channel_norm = channel.copy()
    cv2.normalize(channel, channel_norm, 0, 255, cv2.NORM_MINMAX)

    return channel_norm

def adjust_gamma(img, gamma):
    """Build a lookup table mapping the pixel values [0, 255] to
    their adjusted gamma values.
    """

    # code from
    # https://www.pyimagesearch.com/2015/10/05/opencv-gamma-correction/

    invGamma = 1.0 / gamma
    table = np.array([((i / 255.0) ** invGamma) * 255 for i in np.arange(0, 256)]).astype("uint8")

    # apply gamma correction using the lookup table
    return cv2.LUT(img, table)


def adjust_brightness_with_gamma(gray_img, minimum_brightness, gamma_step = GAMMA_STEP):

    """Adjusts the brightness of an image by saturating the bottom and top
    percentiles, and changing the gamma until reaching the required brightness.
    """
    if 3 <= len(gray_img.shape):
        raise ValueError("Expected a grayscale image, color channels found")

    cols, rows = gray_img.shape
    changed = False
    old_brightness = np.sum(gray_img) / (255 * cols * rows)
    new_img = gray_img
    gamma = 1

    while True:
        brightness = np.sum(new_img) / (255 * cols * rows)
        if brightness >= minimum_brightness:
            break

        gamma += gamma_step
        new_img = adjust_gamma(gray_img, gamma = gamma)
        changed = True

    if changed:
        print("Old brightness: %3.3f, new brightness: %3.3f " %(old_brightness, brightness))
    else:
        print("Maintaining brightness at %3.3f" % old_brightness)

    return new_img

def main(filepath):

    img = cv2.imread(filepath)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    saturated = saturate(gray, 1)
    bright = adjust_brightness_with_gamma(saturated, minimum_brightness = 0.66)

结果在这里并且不如接受的答案：

根据图像，我在接受的答案中使用 alpha-beta 调整，或者我包括 gamma 以避免剪裁太多亮点。 每个步骤的大小，裁剪的百分位数和校正的伽玛，决定了每次调整的权重。

PERCENTILE_STEP = 1
GAMMA_STEP = 0.01

def adjust_brightness_alpha_beta_gamma(gray_img, minimum_brightness, percentile_step = PERCENTILE_STEP, gamma_step = GAMMA_STEP):
    """Adjusts brightness with histogram clipping by trial and error.
    """

    if 3 <= len(gray_img.shape):
        raise ValueError("Expected a grayscale image, color channels found")

    new_img = gray_img
    percentile = percentile_step
    gamma = 1
    brightness_changed = False

    while True:
        cols, rows = new_img.shape
        brightness = np.sum(new_img) / (255 * cols * rows)

        if not brightness_changed:
            old_brightness = brightness

        if brightness >= minimum_brightness:
            break

        # adjust alpha and beta
        percentile += percentile_step
        alpha, beta = percentile_to_bias_and_gain(new_img, percentile)
        new_img = convertScale(gray_img, alpha = alpha, beta = beta)
        brightness_changed = True

        # adjust gamma
        gamma += gamma_step
        new_img = adjust_gamma(new_img, gamma = gamma)

    if brightness_changed:
        print("Old brightness: %3.3f, new brightness: %3.3f " %(old_brightness, brightness))
    else:
        print("Maintaining brightness at %3.3f" % old_brightness)

    return new_img

Answer 4

如果你像这样尝试怎么办：

bright_img = cv2.convertScaleAbs(img, alpha = 1, beta = 255 * (minimum_brightness - brightness))