# Python实现特定场景去除高光算法详解

## 算法思路

1、求取源图I的平均灰度，并记录rows和cols；

2、按照一定大小，分为N*M个方块，求出每块的平均值，得到子块的亮度矩阵D；

3、用矩阵D的每个元素减去源图的平均灰度，得到子块的亮度差值矩阵E；

4、通过插值算法，将矩阵E差值成与源图一样大小的亮度分布矩阵R；

5、得到矫正后的图像result=I-R；

## 代码实现

```import cv2
import numpy as np

def unevenLightCompensate(gray, blockSize):
#gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
average = np.mean(gray)
rows_new = int(np.ceil(gray.shape[0] / blockSize))
cols_new = int(np.ceil(gray.shape[1] / blockSize))
blockImage = np.zeros((rows_new, cols_new), dtype=np.float32)
for r in range(rows_new):
for c in range(cols_new):
rowmin = r * blockSize
rowmax = (r + 1) * blockSize
if (rowmax > gray.shape[0]):
rowmax = gray.shape[0]
colmin = c * blockSize
colmax = (c + 1) * blockSize
if (colmax > gray.shape[1]):
colmax = gray.shape[1]
imageROI = gray[rowmin:rowmax, colmin:colmax]
temaver = np.mean(imageROI)

blockImage[r, c] = temaver

blockImage = blockImage - average
blockImage2 = cv2.resize(blockImage, (gray.shape[1], gray.shape[0]), interpolation=cv2.INTER_CUBIC)
gray2 = gray.astype(np.float32)
dst = gray2 - blockImage2
dst[dst>255]=255
dst[dst<0]=0
dst = dst.astype(np.uint8)
dst = cv2.GaussianBlur(dst, (3, 3), 0)
#dst = cv2.cvtColor(dst, cv2.COLOR_GRAY2BGR)
return dst

if __name__ == '__main__':
file = 'www.png'
blockSize = 8
b,g,r = cv2.split(img)
dstb = unevenLightCompensate(b, blockSize)
dstg = unevenLightCompensate(g, blockSize)
dstr = unevenLightCompensate(r, blockSize)
dst = cv2.merge([dstb, dstg, dstr])
result = np.concatenate([img, dst], axis=1)
cv2.imwrite('result.jpg', result)```

## 补充

OpenCV实现光照去除效果

1.方法一(RGB归一化)

```int main(int argc, char *argv[])
{
//double temp = 255 / log(256);
//cout << "doubledouble temp ="<< temp<(i, j)[0] = 255 * (float)image.at(i, j)[0] / ((float)image.at(i, j)[0] + (float)image.at(i, j)[2] + (float)image.at(i, j)[1]+0.01);
src.at(i, j)[1] = 255 * (float)image.at(i, j)[1] / ((float)image.at(i, j)[0] + (float)image.at(i, j)[2] + (float)image.at(i, j)[1]+0.01);
src.at(i, j)[2] = 255 * (float)image.at(i, j)[2] / ((float)image.at(i, j)[0] + (float)image.at(i, j)[2] + (float)image.at(i, j)[1]+0.01);
}
}

normalize(src, src, 0, 255, CV_MINMAX);

convertScaleAbs(src,src);
imshow("rgb", src);
imwrite("C://Users//TOPSUN//Desktop//123.jpg", src);
waitKey(0);
return 0;
}```

2.方法二

```void unevenLightCompensate(Mat &image, int blockSize)
{
if (image.channels() == 3) cvtColor(image, image, 7);
double average = mean(image)[0];
int rows_new = ceil(double(image.rows) / double(blockSize));
int cols_new = ceil(double(image.cols) / double(blockSize));
Mat blockImage;
blockImage = Mat::zeros(rows_new, cols_new, CV_32FC1);
for (int i = 0; i < rows_new; i++)
{
for (int j = 0; j < cols_new; j++)
{
int rowmin = i*blockSize;
int rowmax = (i + 1)*blockSize;
if (rowmax > image.rows) rowmax = image.rows;
int colmin = j*blockSize;
int colmax = (j + 1)*blockSize;
if (colmax > image.cols) colmax = image.cols;
Mat imageROI = image(Range(rowmin, rowmax), Range(colmin, colmax));
double temaver = mean(imageROI)[0];
blockImage.at(i, j) = temaver;
}
}
blockImage = blockImage - average;
Mat blockImage2;
resize(blockImage, blockImage2, image.size(), (0, 0), (0, 0), INTER_CUBIC);
Mat image2;
image.convertTo(image2, CV_32FC1);
Mat dst = image2 - blockImage2;
dst.convertTo(image, CV_8UC1);
}
int main(int argc, char *argv[])
{
//double temp = 255 / log(256);
//cout << "doubledouble temp ="<< temp<
```