问题描述
我一直在尝试实现以下提供的白平衡算法:
而不是
我哪里出错了?
您正在实施的文档不知道 LAB 定义 8 位色深.
特别是:
L:L/100 * 255答:A + 128乙:乙+128我相信这样做是为了提高准确性，因为这样一来就可以完全使用 unsigned int8 精度来获得亮度，同时为整个数组保持一致的无符号数据类型.
下面的代码，改编自你的应该可以工作.请注意，这里和那里有一些小修正(编辑，包括将有趣的代码包装在一个函数中)，但实际的酱位于嵌套的 for 循环.
from __future__ import (除法、absolute_import、print_function、unicode_literals)将 cv2 导入为 cv将 numpy 导入为 np定义显示(最终):打印('显示')cv.imshow('Temple', final)cv.waitKey(0)cv.destroyAllWindows()# 插入任何带路径的文件名img = cv.imread('grayworld_assumption_0.png')def white_balance_loops(img):结果 = cv.cvtColor(img, cv.COLOR_BGR2LAB)avg_a = np.average(result[:, :, 1])avg_b = np.average(result[:, :, 2])对于范围内的 x(result.shape[0]):对于范围内的 y(result.shape[1]):l, a, b = 结果[x, y, :]# 修正简历修正l *= 100/255.0结果[x, y, 1] = a - ((avg_a - 128) * (l/100.0) * 1.1)结果[x, y, 2] = b - ((avg_b - 128) * (l/100.0) * 1.1)结果 = cv.cvtColor(结果，cv.COLOR_LAB2BGR)返回结果final = np.hstack((img, white_balance_loops(img)))表演(决赛)cv.imwrite('result.jpg', final)相同的结果，但通过避免循环可以获得更快的性能:
def white_balance(img):结果 = cv.cvtColor(img, cv.COLOR_BGR2LAB)avg_a = np.average(result[:, :, 1])avg_b = np.average(result[:, :, 2])结果[:, :, 1] = 结果[:, :, 1] - ((avg_a - 128) * (result[:, :, 0]/255.0) * 1.1)结果[:, :, 2] = 结果[:, :, 2] - ((avg_b - 128) * (result[:, :, 0]/255.0) * 1.1)结果 = cv.cvtColor(结果，cv.COLOR_LAB2BGR)返回结果这显然给出了相同的结果:
print(np.all(white_balance(img) == white_balance_loops(img)))真的但时间非常不同:
%timeit white_balance(img)100 个循环，最好的 3 个:每个循环 2 毫秒%timeit white_balance_loops(img)1 个循环，最好的 3 个:每个循环 529 毫秒I have been trying to implement the white balancing algorithms provided by: https://pippin.gimp.org/image-processing/chapter-automaticadjustments.html
I have used python and opencv to implement them. I am unable to produce the same results as in the website.
In grayworld assumption, for example, i use the following code:
import cv2 as cv
import numpy as np
def show(final):
print 'display'
cv.imshow("Temple", final)
cv.waitKey(0)
cv.destroyAllWindows()
def saveimg(final):
print 'saving'
cv.imwrite("result.jpg", final)
# Insert any filename with path
img = cv.imread("grayworld_assumption_0.png")
res = img
final = cv.cvtColor(res, cv.COLOR_BGR2LAB)
avg_a = -np.average(final[:,:,1])
avg_b = -np.average(final[:,:,2])
for x in range(final.shape[0]):
for y in range(final.shape[1]):
l,a,b = final[x][y]
shift_a = avg_a * (l/100.0) * 1.1
shift_b = avg_b * (l/100.0) * 1.1
final[x][y][1] = a + shift_a
final[x][y][2] = b + shift_b
final = cv.cvtColor(final, cv.COLOR_LAB2BGR)
final = np.hstack((res, final))
show(final)
saveimg(final)
I am getting the result
instead of
Where am I going wrong?
The document you are implementing is not aware of CV internal conventions for LAB definition in case of 8-bit color depth.
In particular:
L: L / 100 * 255
A: A + 128
B: B + 128
I believe this is done for improved accuracy, because then one could use unsigned int8 precision in full for the luminosity while keeping a consistent unsigned data type for the whole array.
The code below, adapted from yours should work.
Note that there are some minor fixes here and there (EDIT including wrapping up the interesting code in a function), but the actual sauce is within the nested for loop.
from __future__ import (
division, absolute_import, print_function, unicode_literals)
import cv2 as cv
import numpy as np
def show(final):
print('display')
cv.imshow('Temple', final)
cv.waitKey(0)
cv.destroyAllWindows()
# Insert any filename with path
img = cv.imread('grayworld_assumption_0.png')
def white_balance_loops(img):
result = cv.cvtColor(img, cv.COLOR_BGR2LAB)
avg_a = np.average(result[:, :, 1])
avg_b = np.average(result[:, :, 2])
for x in range(result.shape[0]):
for y in range(result.shape[1]):
l, a, b = result[x, y, :]
# fix for CV correction
l *= 100 / 255.0
result[x, y, 1] = a - ((avg_a - 128) * (l / 100.0) * 1.1)
result[x, y, 2] = b - ((avg_b - 128) * (l / 100.0) * 1.1)
result = cv.cvtColor(result, cv.COLOR_LAB2BGR)
return result
final = np.hstack((img, white_balance_loops(img)))
show(final)
cv.imwrite('result.jpg', final)
EDIT:
The same result, but with much faster performances can be obtained by avoiding loops:
def white_balance(img):
result = cv.cvtColor(img, cv.COLOR_BGR2LAB)
avg_a = np.average(result[:, :, 1])
avg_b = np.average(result[:, :, 2])
result[:, :, 1] = result[:, :, 1] - ((avg_a - 128) * (result[:, :, 0] / 255.0) * 1.1)
result[:, :, 2] = result[:, :, 2] - ((avg_b - 128) * (result[:, :, 0] / 255.0) * 1.1)
result = cv.cvtColor(result, cv.COLOR_LAB2BGR)
return result
which obviously gives the same result:
print(np.all(white_balance(img) == white_balance_loops(img)))
True
but with very different timings:
%timeit white_balance(img)
100 loops, best of 3: 2 ms per loop
%timeit white_balance_loops(img)
1 loop, best of 3: 529 ms per loop
这篇关于使用 Grayworld 假设进行自动白平衡的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，WP2