Reinhard经典色彩迁移算法

最新推荐文章于 2024-08-02 16:46:02 发布
最新推荐文章于 2024-08-02 16:46:02 发布
阅读量1w 收藏 66
点赞数 13
分类专栏： # 色彩传递
原文链接：https://blog.csdn.net/sin_geek/article/details/22443537
版权
本文详细介绍了Reinhard色彩迁移算法的原理与实现过程，包括如何在lαβ颜色空间中通过调整图像的均值和方差来实现色彩迁移，以及具体的代码实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

下文中，
  目标图像即为要进行染色的图像
  源图像即为色彩源

  Reinhard等人根据lαβ颜色空间中各通道互相不关联的特点，提出了一组适用于各颜色分量的色彩迁移公式，较好的实现了彩色图像之间的色彩迁移。基本思想就是根据着色图像的统计分析确定一个线性变换，使得目标图像和源图像在lαβ空间中具有同样的均值和方差。
  因此需要计算两幅图像的均值和标准方差。假设 l、a、b 是 目标图像 lαβ 通道的数据，L、A、B 分别是 结果图像 lαβ通道的值，ml、ma、mb 和 ml’、ma’、mb’ 分别是的 目标图像 和 源图像 的 lαβ 通道的均值，nl、na、nb 和 nl’、na’、nb’ 表示它们的标准方差。

首先，将 目标图像 lαβ 通道的数据减掉 目标图像 的 lαβ 通道的均值

L1 = l – ml

A1 = a – ma

B1 = b – mb

再将得到的新数据按比例放缩，其放缩系数是两幅图像标准方差的比值(源图像的标准方差 ： 目标图像的标准方差)

L’ = (nl’ / nl)* L1

A’ = (na’ / na)* A1

B’ = (nb’ / nb)* B1

将得到的 L’、A’、B’分别加上 目标图像 lαβ 通道的均值，得到最终数据

L = L’ + ml’

A = A’ + ma’

B = B’ + mb’

整理后得到目标图像与源图像之间的像素关系表达：

（目标图像lab 空间的像素 = （源标准差 / 目标标准差）* （目标像素 - 目标均值）+ 源均值）

L = (nl’ / nl)* (l – ml) + ml’

A = (na’ / na)* (a – ma) + ma’

B = (nb’ / nb)* (b – mb) + mb’

事实上这组式子表示的就是一个线性方程，以两幅图像的标准方差的比值作为斜率，两幅图像各个通道的均值作为一个点。这个简单的线性变换保证了目标图像和着色图像在lαβ颜色空间中具有相同的均值和方差。将变换后l、α、β的值作为新图像三个通道的值，然后显示的时候再将这三个通道转换为RGB值进行显示。

                                 

                                                                                           图 reinhard算法效果图

Reinhard 等人的色彩迁移算法的优点是实现简单，且运行效率很高。但该算法由于是整体色彩迁移，因此它对全局颜色基调单一的图像的有着良好的迁移效果。而对于颜色内容丰富的图像，则效果并不那么明显。一般解决方式是引入人机交互选取样本块的方法，同时还要求用户指定样本块之间的对应关系。这样就给用户增加了许多繁琐的交互。当图像的色彩比较复杂时，用户是无法手工精确地选取样本块的，此时，该算法也将失去作用。

参考了该文章的代码后，自己修改并补全了的代码。结果图如下：

代码：


#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

bool TranRein(uchar* lpDIBBits, int lmageWidth, int lmageHeight, uchar* lpDIBBits2, int lmageWidth2, int lmageHeight2, uchar* lpDIBBits3);
void AverageVariance(double* lpLab, int Width, int Height, double& al, double& aa, double& ab, double& vl, double& va, double& vb);
void RgbToLab(uchar R, uchar G, uchar B, double& l, double& a, double& b);
void LabToRgb(double l, double a, double b, uchar& R, uchar& G, uchar& B);
void mat2Sample(Mat& src, uchar* sample, int nWidth, int nHeight);
void sample2Mat(Mat&src, int nWidth, int nHeight, uchar* sample);

int main()
{
	Mat src = imread("4.jpg", 1);
	int ImageHeight = src.rows;
	int ImageWidth = src.cols;
	uchar* lpDIBBits = new uchar[3 * ImageHeight * ImageWidth];
	mat2Sample(src, lpDIBBits, ImageWidth, ImageHeight);
	imshow("src", src);

	Mat dst = imread("3.jpg", 1);
	int ImageHeight2 = dst.rows;
	int ImageWidth2 = dst.cols;
	uchar* lpDIBBits2 = new uchar[3 * ImageHeight2 * ImageWidth2];
	mat2Sample(dst, lpDIBBits2, ImageWidth2, ImageHeight2);
	imshow("dst", dst);


	uchar* lpDIBBits3 = new uchar[3 * ImageHeight2 * ImageWidth2];

	TranRein(lpDIBBits, ImageWidth, ImageHeight, lpDIBBits2, ImageWidth2, ImageHeight2, lpDIBBits3);

	Mat result(ImageHeight2, ImageWidth2, CV_8UC3);
	sample2Mat(result, ImageWidth2, ImageHeight2, lpDIBBits3);

	imshow("result", result);
	waitKey(0);

}



bool TranRein(uchar* lpDIBBits, int lmageWidth, int lmageHeight, uchar* lpDIBBits2, int lmageWidth2, int lmageHeight2, uchar* lpDIBBits3)
{
	//控制循环
	int i;
	int j;
	long long nindex;
	//a为均值，v为方差，分别为源图像和目标图像的lab通道的均值和方差
	double al, aa, ab, vl, va, vb, al2, aa2, ab2, vl2, va2, vb2;
	//lab空间的矩阵  1源图像，2目标图像，3结果图像
	double* lpImageLab = new  double[lmageWidth*lmageHeight * 3];
	double* lpImageLab2 = new  double[lmageWidth2*lmageHeight2 * 3];
	double* lpImageLab3 = new  double[lmageWidth2*lmageHeight2 * 3];

	//源图像转换为lab，并求lab的均值及标准差
	for (j = 0; j < lmageHeight; j++)
	{
		for (i = 0; i < lmageWidth; i++)
		{
			nindex = (j*lmageWidth + i);
			RgbToLab(lpDIBBits[nindex * 3 + 2], lpDIBBits[nindex * 3 + 1], lpDIBBits[nindex * 3 + 0],
				lpImageLab[nindex * 3 + 0], lpImageLab[nindex * 3 + 1], lpImageLab[nindex * 3 + 2]);
		}
	}
	AverageVariance(lpImageLab, lmageWidth, lmageHeight, al, aa, ab, vl, va, vb);

	//目标图像转换为lab，并求lab的均值及标准差
	for (j = 0; j < lmageHeight2; j++)
	{
		for (i = 0; i < lmageWidth2; i++)
		{
			nindex = (j*lmageWidth2 + i);
			RgbToLab(lpDIBBits2[nindex * 3 + 2], lpDIBBits2[nindex * 3 + 1], lpDIBBits2[nindex * 3 + 0],
				lpImageLab2[nindex * 3 + 0], lpImageLab2[nindex * 3 + 1], lpImageLab2[nindex * 3 + 2]);
		}
	}
	AverageVariance(lpImageLab2, lmageWidth2, lmageHeight2, al2, aa2, ab2, vl2, va2, vb2);


	nindex = 0;
	for (j = 0; j < lmageHeight2; j++)
	{
		for (i = 0; i < lmageWidth2; i++)
		{
			/*nindex = (j*lmageWidth + i);
			lpImageLab3[nindex * 3 + 0] = (lpImageLab[nindex * 3 + 0] - al) * vl2 / vl + al2;
			lpImageLab3[nindex * 3 + 1] = (lpImageLab[nindex * 3 + 1] - aa) * va2 / va + aa2;
			lpImageLab3[nindex * 3 + 2] = (lpImageLab[nindex * 3 + 2] - ab) * vb2 / vb + ab2;*/

			lpImageLab3[nindex] = (lpImageLab2[nindex++] - al2) * vl / vl2 + al;
			lpImageLab3[nindex] = (lpImageLab2[nindex++] - aa2) * va / va2 + aa;
			lpImageLab3[nindex] = (lpImageLab2[nindex++] - ab2) * vb / vb2 + ab;
		}
	}
	求结果图像的lab
	//for (i = 0; i < lmageWidth*lmageHeight; i++)
	//{
	//	lpImageLab3[i * 3 + 0] = (lpImageLab[i * 3 + 0] - al) * vl2 / vl + al2;
	//	lpImageLab3[i * 3 + 1] = (lpImageLab[i * 3 + 1] - aa) * va2 / va + aa2;
	//	lpImageLab3[i * 3 + 2] = (lpImageLab[i * 3 + 2] - ab) * vb2 / vb + ab2;
	//}

	//将结果图像的lab转换为RGB
	for (j = 0; j < lmageHeight2; j++)
	{
		for (i = 0; i < lmageWidth2; i++)
		{
			nindex = (j*lmageWidth2 + i);

			LabToRgb(lpImageLab3[nindex * 3 + 0], lpImageLab3[nindex * 3 + 1], lpImageLab3[nindex * 3 + 2],
				lpDIBBits3[nindex * 3 + 2], lpDIBBits3[nindex * 3 + 1], lpDIBBits3[nindex * 3 + 0]);
		}
	}
	return true;
}


void AverageVariance(double* lpLab, int Width, int Height, double& al, double& aa, double& ab, double& vl, double& va, double& vb)
{
	double suml = 0;
	double suma = 0;
	double sumb = 0;
	double lsuml = 0;
	double lsuma = 0;
	double lsumb = 0;

	//分行求平均，避免和过大而溢出
	for (int j = 0; j < Height; j++)
	{
		for (int i = 0; i < Width; i++)
		{
			lsuml += lpLab[(j*Width + i) * 3];
			lsuma += lpLab[(j*Width + i) * 3 + 1];
			lsumb += lpLab[(j*Width + i) * 3 + 2];
		}
		suml += lsuml / Width;
		suma += lsuma / Width;
		sumb += lsumb / Width;
		lsuml = lsuma = lsumb = 0;
	}
	al = suml / Height;
	aa = suma / Height;
	ab = sumb / Height;

	suml = suma = sumb = 0;
	lsuml = lsuma = lsumb = 0;

	for (int j = 0; j < Height; j++)
	{
		for (int i = 0; i < Width; i++)
		{
			lsuml += pow(lpLab[(j*Width + i) * 3] - al, 2);
			lsuma += pow(lpLab[(j*Width + i) * 3 + 1] - aa, 2);
			lsumb += pow(lpLab[(j*Width + i) * 3 + 2] - ab, 2);
		}
		suml += lsuml / Width;
		suma += lsuma / Width;
		sumb += lsumb / Width;
		lsuml = lsuma = lsumb = 0;
	}
	suml /= Height;
	suma /= Height;
	sumb /= Height;
	vl = sqrt(suml);
	va = sqrt(suma);
	vb = sqrt(sumb);

	/*for (int i = 0; i < Width*Height; i++)
	{
		suml += pow(lpLab[i * 3] - al, 2);
		suma += pow(lpLab[i * 3 + 1] - aa, 2);
		sumb += pow(lpLab[i * 3 + 2] - ab, 2);
	}
	suml /= (Width * Height);
	suma /= (Width * Height);
	sumb /= (Width * Height);
	vl = sqrt(suml);
	va = sqrt(suma);
	vb = sqrt(sumb);*/
}


void RgbToLab(uchar R, uchar G, uchar B, double& l, double& a, double& b)
{
	double L = 0.3811*R + 0.5783*G + 0.0402*B;
	double M = 0.1967*R + 0.7244*G + 0.0782*B;
	double S = 0.0241*R + 0.1288*G + 0.8444*B;

	//若RGB值均为0，则LMS为0，防止数学错误log0
	if (L != 0) L = log(L) / log(10);
	if (M != 0) M = log(M) / log(10);
	if (S != 0) S = log(S) / log(10);

	l = (L + M + S) / sqrt(3);
	a = (L + M - 2 * S) / sqrt(6);
	b = (L - M) / sqrt(2);

}

void LabToRgb(double l, double a, double b, uchar& R, uchar& G, uchar& B)
{
	l /= sqrt(3);
	a /= sqrt(6);
	b /= sqrt(2);
	double L = l + a + b;
	double M = l + a - b;
	double S = l - 2 * a;

	L = pow(10, L);
	M = pow(10, M);
	S = pow(10, S);

	double dR = 4.4679*L - 3.5873*M + 0.1193*S;
	double dG = -1.2186*L + 2.3809*M - 0.1624*S;
	double dB = 0.0497*L - 0.2439*M + 1.2045*S;

	//防止溢出，若求得RGB值大于255则置为255，若小于0则置为0
	if (dR > 255) R = 255;
	else if (dR < 0) R = 0;
	else R = uchar(dR);

	if (dG > 255) G = 255;
	else if (dG < 0) G = 0;
	else G = uchar(dG);

	if (dB > 255) B = 255;
	else if (dB < 0) B = 0;
	else B = uchar(dB);
}


void mat2Sample(Mat& src, uchar* sample, int nWidth, int nHeight)
{
	//uchar* temp;
	long long nindex = 0;
	for (int i = 0; i < nHeight; ++i)
	{
		//temp = src.ptr<uchar>(i);
		for (int j = 0; j < nWidth; ++j)
		{
			///*sample[i*nWidth + j * 3] = temp[j * 3];
			//sample[i*nWidth + j * 3 + 1] = temp[j * 3 + 1];
			//sample[i*nWidth + j * 3 + 2] = temp[j * 3 + 2];*/
			//sample[i*nWidth + j * 3] = src.at<Vec3b>(i, j)[0];
			//sample[i*nWidth + j * 3 + 1] = src.at<Vec3b>(i, j)[1];
			//sample[i*nWidth + j * 3 + 2] = src.at<Vec3b>(i, j)[2];
			sample[nindex++] = src.at<Vec3b>(i, j)[0];
			sample[nindex++] = src.at<Vec3b>(i, j)[1];
			sample[nindex++] = src.at<Vec3b>(i, j)[2];
		}
	}
}

void sample2Mat(Mat&src, int nWidth, int nHeight, uchar* sample)
{
	//uchar* temp;
	long long nindex = 0;
	for (int i = 0; i < nHeight; ++i)
	{
		//temp = src.ptr<uchar>(i);
		for (int j = 0; j < nWidth; ++j)
		{
			/*src.at<Vec3b>(i, j)[0] = sample[i*nWidth + j * 3];
			src.at<Vec3b>(i, j)[1] = sample[i*nWidth + j * 3 + 1];
			src.at<Vec3b>(i, j)[2] = sample[i*nWidth + j * 3 + 2];*/

			/*temp[j * 3] = sample[i*nWidth + j * 3];
			temp[j * 3 + 1] = sample[i*nWidth + j * 3 + 1];
			temp[j * 3 + 2] = sample[i*nWidth + j * 3 + 2];*/

			src.at<Vec3b>(i, j)[0] = sample[nindex++];
			src.at<Vec3b>(i, j)[1] = sample[nindex++];
			src.at<Vec3b>(i, j)[2] = sample[nindex++];

		}
	}

}

之前写过的一个QT项目，里面有 Reinhard、Welsh和FCM色彩迁移算法的实现：https://download.csdn.net/download/qq_38701868/12034242

没下载积分的可百度网盘自取：
链接：https://pan.baidu.com/s/1kW98v9g_Nq1Yj6_YIHW3mQ
提取码：1u97

MATLAB小技巧（13）Reinhard颜色迁移
sinat_34897952的博客
05-04 2425
MATLAB小技巧（11）一维数组极大值查找前言一. Reinhard理论1.1RGB颜色空间1.2Lab颜色空间1.3颜色空间转换二. MATLAB仿真三. 仿真结果四. 小结 前言 MATLAB进行图像处理相关的学习是非常友好的，可以从零开始，对基础的图像处理都已经有了封装好的许多可直接调用的函数，这个系列文章的话主要就是介绍一些大家在MATLAB中常用一些概念函数进行例程演示！ 颜色迁移是图像处理中很有意思的一个应用，可以将一幅图的颜色分布转移到另外一幅图上，使另外一张图也拥有类似的颜色，也可以用来灰
数据图像处理上机实验之颜色传输（OpenCv+Matlab+Python）
m0_73962294的博客
05-12 1315
颜色传输——这是一个好玩的东西，哥们快来看看如何用代码p图吧！
颜色迁移算法
05-26
本代码包含Reinhard算法，KMean均值聚类，FCM模糊聚类等颜色迁移算法，因为年久失修，代码并不完善，但是基本的运行效果是有的。可以给初学者以参考~关于资源分，因为关键代码在lz的博文中都已给出，想看算法的代码直接去文章里看，对于那些伸手就要的童鞋们，要付出一点分的哦~
颜色迁移Reinhard算法代码
07-19
算法流程大体为： 首先，将源图像和目标图像由rgb空间转为lab空间； 其次，分别计算源图像和目标图像均值及标准差； 然后，在lab空间，遍历每个像素点，分别对每个像素点计算各个通道值，计算方法为：将源图像减去自身均值后乘以标准差比值，再将相乘结果加上目标图像均值后赋值给输出图像； 最后，将输出图像由lab空间转为rgb空间。至此，算法执行完毕。
颜色迁移的matlab代码Reinhard
03-31
根据经典的Reinhard算法写的matlab代码 已经可以使用！
颜色迁移之二——Reinhard经典算法
热门推荐
Sin_Geek成长の迹
03-28 1万+
接自上一篇“基础知识”，本文里的色彩空间的转换不再赘述。。。         Reinhard等人根据lαβ颜色空间中各通道互相不关联的特点，提出了一组适用于各颜色分量的色彩迁移公式，较好的实现了彩色图像之间的色彩迁移。基本思想就是根据着色图像的统计分析确定一个线性变换，使得目标图像和源图像在lαβ空间中具有同样的均值和方差。 因此需要计算两幅图像的均值和标准方差。假设l、a、b分别是源图像l
颜色迁移（reinhard VS welsh）
年轻即出发，
12-07 6238
reinhard算法：Color Transfer between Images，作者Erik Reinhard welsh算法：Transferring Color to Greyscale Images，作者Tomihisa Welsh 应用场景： 人像图换肤色，风景图颜色迁移 出发点： RGB三通道有很强的关联性，而做颜色的改变同时恰当地改变三通道比较困难。 需要寻找三通道互不相关的也就是正交的颜色空间，作者想到了Ruderman等人提出的lαβ颜色空间。三个轴向正交意味...
Color_Transfer_Based_On_Reinhard_Method_Reinhard色彩迁移_MATLAB实现_
10-03
**Reinhard色彩迁移算法：** Reinhard方法由Erik Reinhard等人提出，它是一种基于统计的方法，旨在使源图像的色彩分布适应目标图像的色彩分布。该方法首先计算源图像和目标图像的色彩直方图，然后通过某种映射关系来...
matlab实现色彩迁移,色彩迁移— —Reinhard经典算法
weixin_39761696的博客
03-19 1498
颜色迁移— —Reinhard经典算法接自上一篇“基础知识”，本文里的色彩空间的转换不再赘述。。。Reinhard等人根据lαβ颜色空间中各通道互相不关联的特点，提出了一组适用于各颜色分量的色彩迁移公式，较好的实现了彩色图像之间的色彩迁移。基本思想就是根据着色图像的统计分析确定一个线性变换，使得目标图像和源图像在lαβ空间中具有同样的均值和方差。因此需要计算两幅图像的均值和标准方差。假设l、a、b...
Reinhard颜色迁移算法python
最新发布
qq_44304221的博客
08-02 197
【代码】Reinhard颜色迁移算法python。
颜色迁移算法（图形学作业）
01-18
有关颜色迁移的图形学作业，把目标图像的颜色风格迁移到来源图像上
多参考图像的颜色迁移算法
04-13
本文详细论述了多参考图像的颜色迁移算法，颜色迁移算法有效解决设备拍摄显示差异影响，
C# OpenCvSharp 实现Reinhard颜色迁移算法.rar
06-29
C# OpenCvSharp 实现Reinhard颜色迁移算法.rar 博客地址：https://lw112190.blog.csdn.net/article/details/140072078
色彩迁移算法
Mzcc_bbms的博客
01-06 1123
色彩迁移算法色彩迁移算法代码实现 色彩迁移算法 论文《Color Transfer between Images》 原理：在 lab 色彩空间下，调整两幅图像的每个通道，使得均值和方差差不多 代码实现 OpenCV里面集成了这个算法：pip install color_transfer 使用的时候，image_transfer = color_transfer.color_transfer(source, target) 自己复现：（python 版本） """ 2022.1.5
python Reinhard色彩迁移算法代码
weixin_42954710的博客
06-30 1118
原理 Reinhard的原理还是比较简单的，网上也有很多C++的代码复原，但很少有python版本的，所以我自己写了一个。原理我这儿就不说了，网上有很多。直接贴代码吧。去掉了冗余的for循环，速度还可以。 代码 import numpy as np import cv2 import matplotlib.pyplot as plt Is = cv2.imread('./0050l.png') Ir = cv2.imread('./im0.png') plt.imshow(Ir[...,::-1]) pl
基于Matlab Reinhard算法的颜色迁移系统
2301_79809972的博客
05-31 531
一、项目背景与意义在图像处理领域，颜色迁移技术是一种重要的技术，它能够将一幅图像的颜色分布转移到另一幅图像上，实现颜色风格的迁移。这种技术在图像编辑、计算机动画、影视编辑和图像风格化渲染等领域具有广泛的应用。基于Matlab的Reinhard算法是一种有效的颜色迁移算法，它能够在保持目标图像结构信息的同时，成功迁移源图像的颜色风格。因此，本项目旨在利用Matlab实现基于Reinhard算法的颜色迁移系统，以满足不同领域对颜色迁移技术的需求。二、Reinhard算法简介。
python图片颜色迁移_Python OpenCV 实现Reinhard颜色迁移算法
weixin_39574050的博客
12-11 369
# -*- coding: utf-8 -*-import cv2import numpy as npimage = cv2.imread('des.jpg')image = cv2.cvtColor(image,cv2.COLOR_BGR2LAB)original = cv2.imread('src.jpg')original = cv2.cvtColor(original,cv2.COLOR_...
ReinHard颜色迁移
青山渺渺
03-23 1158
看到颜色迁移，觉得还蛮有意思的，遂简单看了一下，代码实现好像有错误，但是不知道错误出在哪里。 算法参考： https://blog.csdn.net/sin_geek/article/details/22443537 https://blog.csdn.net/sin_geek/article/details/22325229 代码实现：希望有高手指出我的错误 理论效果： // ...
《Reinhard颜色迁移算法》读书笔记
studyeboy的专栏
01-03 4173
原理Reinhard等人根据LAB颜色空间中各通道互相不关联的特点，提出了一组适用于各颜色分量的色彩迁移公式，较好的实现了彩色图像之间的色彩迁移。基本思想就是根据着色图像的统计分析确定一个线性变换，使得目标图像和源图像在LAB空间中具有同样的均值和方差。算法流程 将参考图像和目标图像转换到LAB颜色空间下 计算参考图像和目标图像的均值和标准差 目标图像的每个像素值，减去目标图像的均值然后乘以参考图像
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值