retinex算法_OpenCV图像处理专栏十四 | 基于Retinex成像原理的自动色彩均衡算法(ACE)...

最新推荐文章于 2021-06-08 14:23:46 发布
最新推荐文章于 2021-06-08 14:23:46 发布
阅读量503 收藏 1
点赞数
文章标签： retinex算法 图像旋转 错切算法原理

0fa143a03824e2d29475bc28ba6a18bf.png

前言

这个算法是IPOL上一篇名为《Automatic Color Equalization(ACE) and its Fast Implementation》提出的，这实际上也是《快速ACE算法及其在图像拼接中的应用》这篇论文中使用的ACE算法，这个算法主要是基于Retinex成像理论做的自动彩色均衡，我用C++ OpenCV实现了，来分享一下。

算法原理

在论文介绍中提到，高动态图像是指在一幅图像中，既有明亮的区域又有阴影区域，为了使细节清晰，需要满足以下几点：

  • （1）对动态范围具有一定的压缩能力
  • （2）对亮暗区域的细节有一定的显示能力
  • （3）在满足(1)，(2)的条件下不破坏图像的清晰度

Rizzi等人根据Retinex理论提出自动色彩均衡算法，该算法考虑了图像中颜色和亮度的空间位置关系，进行局部的自适应滤波，实现具有局部和非线性特征的图像亮度，色彩与对比度调整，同时满足灰度世界理论和白斑点假设。

朴素的ACE算法实现

获得空域重构图像

对图像进行色彩/空域调整，完成图像的色差矫正，得到空域重构图像：

其中

是中间结果，
为2个点的亮度差，
表示距离度量函数，
为亮度表现函数，需要是奇函数，这一步可以适应局部图像对比度，
可以放大较小的差异，并丰富大的差异，根据局部内容扩展或者压缩动态范围。一般的，
为：

对矫正后的图像进行动态扩展

对矫正后的图像进行动态扩展，一种简单的线性扩展为：

，

其中

是
的斜率，其中：

，

我们还可以将其映射到

的空间中：

我实现代码时选择了后者，效果会好一点。

快速ACE算法实现

在查阅资料[参考2]的时候看到一个非常有趣的改进方法，可以让ACE算法速度更快，更利于实际应用。

快速ACE算法基于两个基本假设：(1)对一副图像ACE增强后得到输出

，如果对
再进行一次ACE增强，输出仍然是
本身；(2）对一副图像的ACE增强结果进行尺寸缩放得到
，对
进行ACE增强，输出仍然是
本身。

如果上面假设成立，我们就可以对图像进行缩放得到

，对
的ACE增强结果进行尺度放大（与
尺寸一样）得到
，那么
和
是非常接近的，我们只需要在
基础上进一步处理即可。这里就又引申了两个细节问题：
  • 「如何快速的求
    的ACE增强结果？」
    其实很简单，对它再次缩放得到
    ，求
    的增强结果，依次类推就是金字塔结构思想。
  • 「如何在
    基础上进一步处理得到
    ？」
    因为是在整个图像域进行差分比较运算，与近处邻域像素的比较构成了
    的细节信息，与远处像素的比较构成了
    的全局背景信息，那么我们合理假设，
    和
    的全局背景信息相同，只更新细节信息即可。所以，我们需要在
    的基础上加上
    中邻近像素的差分结果，并减去
    中邻近像素的差分结果就是最终的输出
    。

注意，这种方法不是论文中使用的改进方法，之所以要介绍这种方法是因为它操作起来很简单，同时原理也比较好懂。关于论文中使用的快速ACE算法加速技巧比较复杂，有兴趣可以去看原论文。

代码

#include <stdio.h>
#include <iostream>
#include <immintrin.h>
#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/ml/ml.hpp>
#include "opencv2/highgui/highgui.hpp"
using namespace cv;
using namespace cv::ml;
using namespace std;

namespace ACE {
	//Gray
	Mat stretchImage(Mat src) {
		int row = src.rows;
		int col = src.cols;
		Mat dst(row, col, CV_64FC1);
		double MaxValue = 0;
		double MinValue = 256.0;
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				MaxValue = max(MaxValue, src.at<double>(i, j));
				MinValue = min(MinValue, src.at<double>(i, j));
			}
		}
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				dst.at<double>(i, j) = (1.0 * src.at<double>(i, j) - MinValue) / (MaxValue - MinValue);
				if (dst.at<double>(i, j) > 1.0) {
					dst.at<double>(i, j) = 1.0;
				}
				else if (dst.at<double>(i, j) < 0) {
					dst.at<double>(i, j) = 0;
				}
			}
		}
		return dst;
	}

	Mat getPara(int radius) {
		int size = radius * 2 + 1;
		Mat dst(size, size, CV_64FC1);
		for (int i = -radius; i <= radius; i++) {
			for (int j = -radius; j <= radius; j++) {
				if (i == 0 && j == 0) {
					dst.at<double>(i + radius, j + radius) = 0;
				}
				else {
					dst.at<double>(i + radius, j + radius) = 1.0 / sqrt(i * i + j * j);
				}
			}
		}
		double sum = 0;
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size; j++) {
				sum += dst.at<double>(i, j);
			}
		}
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size; j++) {
				dst.at<double>(i, j) = dst.at<double>(i, j) / sum;
			}
		}
		return dst;
	}

	Mat NormalACE(Mat src, int ratio, int radius) {
		Mat para = getPara(radius);
		int row = src.rows;
		int col = src.cols;
		int size = 2 * radius + 1;
		Mat Z(row + 2 * radius, col + 2 * radius, CV_64FC1);
		for (int i = 0; i < Z.rows; i++) {
			for (int j = 0; j < Z.cols; j++) {
				if((i - radius >= 0) && (i - radius < row) && (j - radius >= 0) && (j - radius < col)) {
					Z.at<double>(i, j) = src.at<double>(i - radius, j - radius);
				}
				else {
					Z.at<double>(i, j) = 0;
				}
			}
		}

		Mat dst(row, col, CV_64FC1);
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				dst.at<double>(i, j) = 0.f;
			}
		}
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size; j++) {
				if (para.at<double>(i, j) == 0) continue;
				for (int x = 0; x < row; x++) {
					for (int y = 0; y < col; y++) {
						double sub = src.at<double>(x, y) - Z.at<double>(x + i, y + j);
						double tmp = sub * ratio;
						if (tmp > 1.0) tmp = 1.0;
						if (tmp < -1.0) tmp = -1.0;
						dst.at<double>(x, y) += tmp * para.at<double>(i, j);
					}
				}
			}
		}
		return dst;
	}

	Mat FastACE(Mat src, int ratio, int radius) {
		int row = src.rows;
		int col = src.cols;
		if (min(row, col) <= 2) {
			Mat dst(row, col, CV_64FC1);
			for (int i = 0; i < row; i++) {
				for (int j = 0; j < col; j++) {
					dst.at<double>(i, j) = 0.5;
				}
			}
			return dst;
		}
		
		Mat Rs((row + 1) / 2, (col + 1) / 2, CV_64FC1);
		
		resize(src, Rs, Size((col + 1) / 2, (row + 1) / 2));
		Mat Rf= FastACE(Rs, ratio, radius);
		resize(Rf, Rf, Size(col, row));
		resize(Rs, Rs, Size(col, row));
		Mat dst(row, col, CV_64FC1);
		Mat dst1 = NormalACE(src, ratio, radius);
		Mat dst2 = NormalACE(Rs, ratio, radius);
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				dst.at<double>(i, j) = Rf.at<double>(i, j) + dst1.at<double>(i, j) - dst2.at<double>(i, j);
			}
		}
		return dst;
	}

	Mat getACE(Mat src, int ratio, int radius) {
		int row = src.rows;
		int col = src.cols;
		vector <Mat> v;
		split(src, v);
		v[0].convertTo(v[0], CV_64FC1);
		v[1].convertTo(v[1], CV_64FC1);
		v[2].convertTo(v[2], CV_64FC1);
		Mat src1(row, col, CV_64FC1);
		Mat src2(row, col, CV_64FC1);
		Mat src3(row, col, CV_64FC1);

		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				src1.at<double>(i, j) = 1.0 * src.at<Vec3b>(i, j)[0] / 255.0;
				src2.at<double>(i, j) = 1.0 * src.at<Vec3b>(i, j)[1] / 255.0;
				src3.at<double>(i, j) = 1.0 * src.at<Vec3b>(i, j)[2] / 255.0;
			}
		}
		src1 = stretchImage(FastACE(src1, ratio, radius));
		src2 = stretchImage(FastACE(src2, ratio, radius));
		src3 = stretchImage(FastACE(src3, ratio, radius));

		Mat dst1(row, col, CV_8UC1);
		Mat dst2(row, col, CV_8UC1);
		Mat dst3(row, col, CV_8UC1);
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				dst1.at<uchar>(i, j) = (int)(src1.at<double>(i, j) * 255);
				if (dst1.at<uchar>(i, j) > 255) dst1.at<uchar>(i, j) = 255;
				else if (dst1.at<uchar>(i, j) < 0) dst1.at<uchar>(i, j) = 0;
				dst2.at<uchar>(i, j) = (int)(src2.at<double>(i, j) * 255);
				if (dst2.at<uchar>(i, j) > 255) dst2.at<uchar>(i, j) = 255;
				else if (dst2.at<uchar>(i, j) < 0) dst2.at<uchar>(i, j) = 0;
				dst3.at<uchar>(i, j) = (int)(src3.at<double>(i, j) * 255);
				if (dst3.at<uchar>(i, j) > 255) dst3.at<uchar>(i, j) = 255;
				else if (dst3.at<uchar>(i, j) < 0) dst3.at<uchar>(i, j) = 0;
			}
		}
		vector <Mat> out;
		out.push_back(dst1);
		out.push_back(dst2);
		out.push_back(dst3);
		Mat dst;
		merge(out, dst);
		return dst;
	}
}

using namespace ACE;

int main() {
	Mat src = imread("F:sky.jpg");
	Mat dst = getACE(src, 4, 7);
	imshow("origin", src);
	imshow("result", dst);
	waitKey(0);
}

效果

7f21bb04a582d1bcdc3cdcc92fa16114.png

8f7d355217b8d0d86e7e60cee114e746.png

090309181d8f1c3d1a7582c0bbc2de0c.png

75c6999e1876fff85dea93d8ebc77e52.png

b4a0795903a8629b1c9da079376628b6.png

8eb705f32b318f72f0142943025edc2d.png

3b8e508da7d2a6b0f34a5438d51c2061.png

675aed1fb4466d1f4293ca2d821e0eed.png

参考

  • 论文原文：http://www.ipol.im/pub/art/2012/g-ace/
  • 作者开源代码：http://www.ipol.im/pub/art/2012/g-ace/
  • 参考1：https://blog.csdn.net/piaoxuezhong/article/details/78357815
  • 参考2：https://www.cnblogs.com/whw19818/p/5765995.html

同期文章

  • OpenCV图像处理专栏一 | 盘点常见颜色空间互转
  • OpenCV图像处理专栏二 |《Local Color Correction 》论文阅读及C++复现
  • OpenCV图像处理专栏三 | 灰度世界算法原理和实现
  • OpenCV图像处理专栏四 | 自动白平衡之完美反射算法原理及C++实现
  • OpenCV图像处理专栏五 | ACE算法论文解读及实现
  • OpenCV图像处理专栏六 | 来自何凯明博士的暗通道去雾算法(CVPR 2009最佳论文)
  • OpenCV图像处理专栏七 | 直方图均衡化算法及代码实现
  • OpenCV图像处理专栏八 | 《Contrast image correction method》 论文阅读及代码实现
  • OpenCV图像处理专栏九 | 基于直方图的快速中值滤波算法
  • OpenCV图像处理专栏十 | 利用中值滤波进行去雾
  • OpenCV图像处理专栏十一 | IEEE Xplore 2015的图像白平衡处理之动态阈值法
  • OpenCV图像处理专栏十二 |《基于二维伽马函数的光照不均匀图像自适应校正算法》
  • OpenCV图像处理专栏十三 | 利用多尺度融合提升图像细节

欢迎关注GiantPandaCV, 在这里你将看到独家的深度学习分享，坚持原创，每天分享我们学习到的新鲜知识。( • ̀ω•́ )✧

有对文章相关的问题，或者想要加入交流群，欢迎添加BBuf微信：

https://u.wechat.com/MPWFDnmCPu6zgf5YUtdpT_U (二维码自动识别)

weixin_39538847
关注
Retinex图像增强算法
weixin_30793643的博客
04-20 4235
前一段时间研究了一下图像增强算法，发现Retinex理论在彩色图像增强、图像去雾、彩色图像恢复方面拥有很好的效果，下面介绍一下我对该算法的理解。 Retinex理论 Retinex理论始于Land和McCann于20世纪60年代作出的一系列贡献,其基本思想是人感知到某点的颜色和亮度并不仅仅取决于该点进入人眼的绝对光线，还和其周围的颜色和亮度有关。Retinex这个词是由视网膜(Retina)和大...
基于OpenCV实现Retinex
09-21
国外大牛写的Retinex图像处理，可用于图像增强，去雾等应用。
OpenCV图像处理算法——14（基于Retinex成像原理的自动色彩均衡算法(ACE)）
weixin_45709330的博客
02-25 1334
基于Retinex成像原理的自动色彩均衡算法(ACE) 前言 这个算法是IPOL上一篇名为《Automatic Color Equalization(ACE) and its Fast Implementation》提出的，这实际上也是《快速ACE算法及其在图像拼接中的应用》这篇论文中使用的ACE算法，这个算法主要是基于Retinex成像理论做的自动彩色均衡，我用C++ OpenCV实现了，来分享...
Retinex算法，C++，opencv
06-02
用opencv实现retinex算法，包括单尺度和多尺度Retinex
改进retinex算法实现人脸光照.rar_retinex_trybfn_图像增强_图像处理_改进retinex算法实现人脸光照
07-14
为了提高光照变化条件下的人脸识别率，针对Retinex算法处理人脸侧光照图像时会误增强阴影的边缘提出了一 种基于新的传导函数的自适应平滑Retinex算法。该传导函数用空间梯度和像素的局部不一致性两种方式共同测量灰 ...
图像去雾.zip_MSR 图像_retinex 去雾_retinex算法去雾_彩色图像MSR_彩色图像去雾
07-15
总结来说，这个压缩包提供了三种基于Retinex理论的图像去雾算法，它们在处理彩色图像时各有优势。单尺度Retinex适用于简单场景，多尺度Retinex则更适合处理复杂场景，而MSRCR在保持色彩准确性方面表现更优。通过理解...
retinex-MCCANN.zip_Retinex增强_retinex算法_单尺度retinex_单尺度算法_图像增强Reti
07-13
基于retinex的图像增强，单尺度retinex算法
Retinex.rar_MSR retinex_MSR的 matlab_多尺度retinex_多尺度算法_彩色图像
07-15
多尺度Retinex算法因其在增强图像细节、恢复图像的原始色彩和提高图像对比度方面的优秀性能，在图像处理、计算机视觉、医学成像等领域有广泛应用。例如，它可以用于改善低光照条件下的照片，修复旧照片，或者在医疗...
Retinex.rar_matlab retinex_retinex_retinex matlab_retinex算法
07-13
由于Retinex算法的效果显著，它常被应用于医学成像、遥感图像分析、艺术图像处理等多个领域。 总结起来，"Retinex.rar_matlab retinex_retinex_retinex matlab_retinex算法"是一个与Matlab实现的Retinex算法相关的...
Retinex SSR算法opencv
05-26
用opencv编写的Retinex SSR算法代码，代码简单，运行结果比较好
基于Retinex的图像增强算法-Opencv-C++
10-25
一种常见图像增强算法，基于Retinex理论。本代码通过vs2015编译通过，Opencv3.1.0，C++
C++基于 Retinex 的图像增强算法-Opencv-C++.zip
05-09
C++基于 Retinex 的图像增强算法-Opencv-C++。 一种常见图像增强算法，基于Retinex理论。本代码通过vs2015编译通过，Opencv3.1.0，C++ opencv c++ Retinex 图像增强
（MATLAB代码）Retinex算法解决光照不均问题
10-11
Retinex算法解决光照不均问题的MATLAB代码实现，可直接运行出结果，有注释。 （另外，代码最后的注释部分为利用顶帽变换方法处理光照不均问题。在本人处理的实际问题中，顶帽变换算法不理想，但Retinex算法的处理结果很好。）
色彩平衡matlab代码
04-04
采用matlab编程，对给定的图像stone.jpg进行色彩平衡处理。假设已知位于图像中石头上的某像素点的坐标为（148，206），并认为原来应当为灰色。由于图像发生了色偏，该像素有明显的偏红色现象。因此通过色彩平衡处理之后，我们期待图像中的石头能够得以恢复其灰色特征。
OpenCV—Python Retinex图像增强算法
jgw2008的专栏
06-08 3054
Retinex图像增强算法 一、单尺度SSR(Single Scale Retinex)理论 Retinex理论始于Land和McCann于20世纪60年代作出的一系列贡献,其基本思想是人感知到某点的颜色和亮度并不仅仅取决于该点进入人眼的绝对光线，还和其周围的颜色和亮度有关。Retinex这个词是由视网膜(Retina)和大脑皮层(Cortex)两个词组合构成的.Land之所以设计这个词，是为了表明他不清楚视觉系统的特性究竟取决于此两个生理结构中的哪一个，抑或是与两者都有关系 —————————————
OpenCV—python 自动色彩均衡（ACE）
红叶谷 wsp_1138886114的博客
06-19 8241
ACE算法源自retinex算法，可以调整图像的对比度，实现人眼色彩恒常性和亮度恒常性，通过差分来计算目标点与周围像素点的相对明暗关系来校正最终像素值，有很好的增强效果。但是计算复杂度非常高，本文提出一种有效的快速实现方法。 为叙述方便，这里假设后面的图像都是归一化到[0,1]之间的浮点数图像。 ACE算法的计算公式为： Y = ∑(g(I(x0)-I(x))w(x0,x)) / ∑(w...
OpenCV中基于Retinex的图像增强实现
zy010101博客
03-19 3619
美国物理学家埃德温∙兰德（Edwin Land） 在 1971 年提出一种被称为色彩的理论，并在颜色恒常性的基础上提出的一种图像增强方法。Retinex 理论认为物体的颜色是由物体对长波、中波和短波光线的反射能力决定的，而不是由反射光强度的绝对值决定的，即物体的色彩不受光照非均性的影响，具有一致性。 根据 Retinex 理论，它会将一幅给定的图像 S(x,y)分解成两幅不同的图像：反射物体图...
自动色彩均衡算法（ACE）原理及实现
热门推荐
满城风絮
10-26 2万+
前注：ACE在图像处理方面可以有两种表示，一种是本篇要说的:Automatic Color Equalization，即自动彩色均衡；还有一种是：Adaptive Contrast Enhancement，即自适应对比度增强 。不要搞混了~_~ 自动彩色均衡算法原理: Rizzi等依据Retinex理论提出了自动颜色均衡算法，该算法考虑了图像中颜色和亮度的空间位置关系，进行局部特性的自
改进Retinex算法提升人脸图像光照处理及识别性能
本文主要探讨了在人脸识别领域如何通过改进的Retinex算法来处理人脸图像的光照问题。Retinex算法是一种经典的图像复原技术，旨在模拟人眼对自然光照的理解，将图像分解为光照和反射两个部分。然而，传统Retinex在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值