标签：gray 高光 Python blockSize image float int 去除 new

1、

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
    im01 = cv2.imread(file)
    b_img,g_img,r_img = cv2.split(im01)
    dstb_img_img = unevenLightCompensate(b_img, blockSize)
    dstg_img = unevenLightCompensate(g_img, blockSize)
    dstr_img = unevenLightCompensate(r_img, blockSize)
    im02 = cv2.merge([dstb_img, dstg_img, dstr_img])
    result = np.concatenate([im01, im02], axis=1)
cv2.imwrite('result.jpg', result)
    

2、方法一(RGB归一化)

int main(int argc, char *argv[])
{
    //double temp = 255 / log(256);
    //cout << "doubledouble temp ="<< temp<<endl;
     
    Mat  image = imread("D://vvoo//sun_face.jpg", 1);
    if (!image.data)
    {
        cout << "image loading error" <<endl;
        return -1;
    }
    imshow("原图", image);
    Mat src(image.size(), CV_32FC3);
    for (int i = 0; i < image.rows; i++)
    {
        for (int j = 0; j < image.cols; j++)
        {
            src.at<Vec3f>(i, j)[0] = 255 * (float)image.at<Vec3b>(i, j)[0] / ((float)image.at<Vec3b>(i, j)[0] + (float)image.at<Vec3b>(i, j)[2] + (float)image.at<Vec3b>(i, j)[1]+0.01);
            src.at<Vec3f>(i, j)[1] = 255 * (float)image.at<Vec3b>(i, j)[1] / ((float)image.at<Vec3b>(i, j)[0] + (float)image.at<Vec3b>(i, j)[2] + (float)image.at<Vec3b>(i, j)[1]+0.01);
            src.at<Vec3f>(i, j)[2] = 255 * (float)image.at<Vec3b>(i, j)[2] / ((float)image.at<Vec3b>(i, j)[0] + (float)image.at<Vec3b>(i, j)[2] + (float)image.at<Vec3b>(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;
}

3、

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<float>(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<<endl;
     
    Mat  image = imread("C://Users//TOPSUN//Desktop//2.jpg", 1);
    if (!image.data)
    {
        cout << "image loading error" <<endl;
        return -1;
    }
    imshow("原图", image);
    unevenLightCompensate(image, 12);
    imshow("rgb", image);
    imwrite("C://Users//TOPSUN//Desktop//123.jpg", image);
    waitKey(0);
    return 0;
}

参考：https://www.zhuxianfei.com/python/56327.html

#########################

标签：gray,高光,Python,blockSize,image,float,int,去除,new
来源： https://www.cnblogs.com/herd/p/16340902.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。