[C++][opencv]基于opencv实现photoshop算法高反差保留

已于 2024-08-13 07:02:11 修改
阅读量401 收藏
点赞数 2
分类专栏： C/C++ 文章标签： c++ opencv 开发语言
于 2024-08-13 06:59:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FL1623863129/article/details/141147282
版权

【测试环境】

vs2019

opencv==4.8.0

【效果演示】

【核心代码实现】

Filter.hpp

#ifndef OPENCV2_PHOTOS_FILTER_HPP_
#define OPENCV2_PHOTOS_FILTER_HPP_

#include "opencv2/core.hpp"
#include "opencv2/imgproc.hpp"

namespace cv {

class Filter {
public:
	Filter();
	virtual ~Filter();

	/**
	 * Gaussian Blur
	 *
	 * @param src [in]  InputArray
	 * @param dst [out] OutputArray
	 * @param radius [in] Gaussian radius, value range [0.1, 250]
	 *
	 * @return 0 if success, else return error code
	 */
	static int GaussianBlur(InputArray src, OutputArray dst, float radius);

	/**
	 * High Pass
	 *
	 * @param src [in]  InputArray
	 * @param dst [out] OutputArray
	 * @param radius [in] Gaussian radius, value range [0.1, 250]
	 *
	 * @return 0 if success, else return error code
	 */
	static int HighPass(InputArray src, OutputArray dst, float radius);


	static int AddNoise(InputArray src, OutputArray dst);

	/**
	 * Ripple
	 *
	 * @param src [in]  InputArray
	 * @param dst [out] OutputArray
	 * @param center [in] center point of ripple
	 * @param radius [in] radius of ripple
	 * @param phases [in]
	 * @param waveLength [in] wave length
	 * @param amplitude [in] amplitude
	 *
	 * @return 0 if success, else return error code
	 */
	static int Ripple(InputArray src, OutputArray dst, Point center, float radius,
			float phases = 0, int waveLength = 0, int amplitude = 0);

	/**
	 * Pinch
	 *
	 * @param src [in]  InputArray
	 * @param dst [out] OutputArray
	 *
	 * @return 0 if success, else return error code
	 */
	static int Pinch(InputArray src, OutputArray dst, float amount = 0.5, Point center = Point(0,0), float radius = 0.6 );


	/**
	 * Kaleidoscope
	 *
	 * @param src [in]  InputArray
	 * @param dst [out] OutputArray
	 *
	 * @return 0 if success, else return error code
	 */
	static int Kaleidoscope(InputArray src, OutputArray dst);
};

} /* namespace cv */

#endif /* OPENCV2_PHOTOS_FILTER_HPP_ */

 Filter.cpp

#include "Filter.hpp"
#include <math.h>
#include <iostream>

#define CLIP_RANGE(value, min, max)  ( (value) > (max) ? (max) : (((value) < (min)) ? (min) : (value)) )
#define COLOR_RANGE(value)  CLIP_RANGE((value), 0, 255)
#define M_PI 3.14
namespace cv {

Filter::Filter() {

}

Filter::~Filter() {
}

/**
 * Gaussian Blur
 *
 * @param src [in]  InputArray
 * @param dst [out] OutputArray
 * @param radius [in] Gaussian radius, value range [0.1, 250]
 *
 * @return 0 if success, else return error code
 */
int Filter::GaussianBlur(InputArray src, OutputArray dst, float radius)
{
	if ( radius < 0.1 ) return -1;
	if ( radius > 250 ) return -1;
	cv::GaussianBlur(src, dst, Size(0,0), radius, radius);
	return 0;
}

/**
 * High Pass
 *
 * @param src [in]  InputArray
 * @param dst [out] OutputArray
 * @param radius [in] Gaussian radius, value range [0.1, 250]
 *
 * @return 0 if success, else return error code
 */
int Filter::HighPass(InputArray src, OutputArray dst, float radius)
{
	Mat input = src.getMat();
	if( input.empty() ) {
		return -1;
	}

	dst.create(src.size(), src.type());
	Mat output = dst.getMat();

	if ( radius < 0.1 ) return -1;
	if ( radius > 250 ) return -1;
	cv::GaussianBlur(input, output, Size(0, 0), radius, radius);

	const uchar *in;
	uchar *out;
	int width = input.cols;
	int height = input.rows;
	int channels = input.channels();

	for (int y = 0; y < height; ++y) {
		in = input.ptr<uchar>(y);
		out = output.ptr<uchar>(y);
		for (int x = 0; x < width; ++x) {
			for (int i = 0; i < 3; ++i ) {
				*out = COLOR_RANGE((*in - *out) + 127);
				++out; ++in;
			}

			for (int i = 0; i < channels-3; ++i) {
				*out++ = *in++;
			}
		}
	}
	return 0;
}



int Filter::AddNoise(InputArray src, OutputArray dst)
{
	Mat input = src.getMat();
	if( input.empty() ) {
		return -1;
	}

	dst.create(src.size(), src.type());
	Mat output = dst.getMat();

	//output = input.clone();
	cv::randn(output, 0.5, 0.25);
}

#define PRINT_VAR(a) std::cout << #a << "= " << a << std::endl

/**
 * Ripple
 *
 * @param src [in]  InputArray
 * @param dst [out] OutputArray
 * @param center [in] center point of ripple
 * @param radius [in] radius of ripple
 * @param phases [in]
 * @param waveLength [in] wave length
 * @param amplitude [in] amplitude
 *
 * @return 0 if success, else return error code
 */
int Filter::Ripple(InputArray src, OutputArray dst, Point center, float radius, float phases,
		int wave_length, int amplitude_in)
{
	Mat input = src.getMat();
	if( input.empty() ) {
		return -1;
	}

	dst.create(src.size(), src.type());
	Mat output = dst.getMat();

	int width = input.cols;
	int height = input.rows;

	float centreX = center.x * 1.0 / width; //0.25;
	float centreY = center.y * 1.0  / height; //0.5;
	//float radius = 90;

	if (radius==0)
		radius = std::min(width, height) / 2;

	int wavelength = (wave_length == 0) ?  radius / 2 : wave_length; //50;
	int amplitude = (amplitude_in == 0) ? wavelength / 4 : amplitude_in; //20

	if ( phases <= 2) phases = 4;
	float phase = M_PI / phases; // default = M_PI / 4;

	float icentreX=width*centreX;
	float icentreY=height*centreY;
	float radius2=radius*radius;

	float dx,dy,new_x,new_y;
	float p,q,x1,y1; //,x0,y0;
	float distance, distance2;
	float amount;

	for (int y=0; y<height; y++)
	{
		for (int x=0; x<width; x++)
		{

			 dx = x-icentreX;
			 dy = y-icentreY;

			 distance2=dx*dx+dy*dy;

			 if (distance2>radius2)
			 {
				 new_x=x;
				 new_y=y;
			 }
			 else
			 {
				 distance=sqrt(distance2);
				 amount=amplitude * sin(distance / wavelength * 2*M_PI - phase);
				 amount =amount* (radius-distance)/radius;
				 amount=amount*wavelength/(distance+0.0001);

				 new_x =x + dx*amount;
				 new_y =y + dy*amount;
			 }

			if(new_x<0)         new_x=0;
			if(new_x>=width-1)  new_x=width-2;
			if(new_y<0)         new_y=0;
			if(new_y>=height-1) new_y=height-2;

			x1=(int)new_x;
			y1=(int)new_y;

			p=new_x-x1;
			q=new_y-y1;

			for (int k=0; k<3; k++)
			{
				output.at<Vec3b>(y, x)[k]=(1-p)*(1-q)*input.at<Vec3b>(y1, x1)[k]+
										(p)*(1-q)*input.at<Vec3b>(y1,x1+1)[k]+
										(1-p)*(q)*input.at<Vec3b>(y1+1,x1)[k]+
										(p)*(q)*input.at<Vec3b>(y1+1,x1+1)[k];
			}

		}
	}
	return 0;
}

int  Filter::Pinch(InputArray src, OutputArray dst, float amount, Point center, float radiusPercent)
{
	Mat input = src.getMat();
	if( input.empty() ) {
		return -1;
	}

	dst.create(src.size(), src.type());
	Mat output = dst.getMat();


	int width = input.cols;
	int height = input.rows;

	float angle = M_PI / 2;
	float centreX = 0.5;
	float centreY = 0.5;

	float radius = std::min(width, height) * radiusPercent ;
	//float amount = 0.5;
	std::cout << amount << std::endl;

	if (radius==0)
		radius = std::min(width, height) / 2;

	float icentreX = width * centreX;
	float icentreY = height * centreY;

	if (center.x != 0 || center.y != 0) {
		icentreX = center.x;
		icentreY = center.y;
	}

	float radius2 = radius * radius;

	float dx, dy, new_x, new_y;
	float p, q, x1 ,y1;
	float distance;
	float a, d, t, s, c, e;

	for (int y = 0; y < height; ++y)
	{
		for (int x = 0; x < width; ++x)
		{
			 dx = x - icentreX;
			 dy = y - icentreY;

			 distance = dx*dx + dy*dy;

			 if (distance > radius2 || distance == 0)
			 {
				 new_x = x;
				 new_y = y;
			 }
			 else
			 {
				d  =  sqrt( distance / radius2 );
				t  =  pow( sin( M_PI * 0.5 * d ), -amount );

				dx  = dx* t;
				dy  = dy* t;

				e = 1 - d;
				a = angle * e * e;

				s = sin( a );
				c = cos( a );

				new_x = icentreX + c*dx - s*dy;
				new_y = icentreY + s*dx + c*dy;
			 }

			if(new_x<0)         new_x = 0;
			if(new_x>=width-1)  new_x = width - 2;
			if(new_y<0)         new_y = 0;
			if(new_y>=height-1) new_y = height - 2;

			x1=(int)new_x;
			y1=(int)new_y;

			p = new_x - x1;
			q = new_y - y1;

			for (int k = 0; k < 3; k++)
			{
				output.at<Vec3b>(y, x)[k]=(1-p)*(1-q)*input.at<Vec3b>(y1, x1)[k]+
										(p)*(1-q)*input.at<Vec3b>(y1,x1+1)[k]+
										(1-p)*(q)*input.at<Vec3b>(y1+1,x1)[k]+
										(p)*(q)*input.at<Vec3b>(y1+1,x1+1)[k];
			}

		}
	}
	return 0;
}


static float Triangle(float x)
{
    float temp_r = fmod(x, 1.0);

    if (temp_r < 0.5) {
       return 2 * temp_r;
    } else {
       return 2 * (1 - temp_r);
    }
}

int Filter::Kaleidoscope(InputArray src, OutputArray dst)
{
	Mat input = src.getMat();
	if( input.empty() ) {
		return -1;
	}

	dst.create(src.size(), src.type());
	Mat output = dst.getMat();

	//const uchar *in;
	//uchar *out;
	int width = input.cols;
	int height = input.rows;
	//int channels = input.channels();

	float angle = M_PI / 4;
	float angle2 = M_PI / 4;
	float centreX = 0.5;
	float centreY = 0.5;
	float sides = 4;

	float icentreX = width * centreX;
	float icentreY = height * centreY;
	float radius = 150;

	float dx, dy, new_x, new_y;
	float p, q, x1, y1;
	float c, r, theta, temp_theta, radius_c;

	for (int i = 0; i < height; ++i)
	{
		for (int j = 0; j < width; ++j)
		{
			 dx = j - icentreX;
			 dy = i - icentreY;

			 theta = atan2(dy, dx) - angle - angle2;
			 r = sqrt( dy * dy + dx * dx );

			 temp_theta = theta / M_PI * sides * 0.5;
			 theta = Triangle (temp_theta);

			 if (radius)
			 {
				c = cos(theta);
				radius_c = radius/c;
				r=radius_c * Triangle( r / radius_c );
			 }


			theta = theta + angle;

			new_x = r * cos(theta) + icentreX;
			new_y = r * sin(theta) + icentreY;

			if(new_x<0)         new_x = 0;
			if(new_x>=width-1)  new_x = width-2;
			if(new_y<0)         new_y = 0;
			if(new_y>=height-1) new_y = height-2;

//		    if (new_x < 0)     continue;
//		    if (new_x >= width-1)   continue;
//		    if (new_y >= height-1)  continue;
//		    if (new_y < 0)  continue;

			x1 = (int) new_x;
			y1 = (int) new_y;

			p = new_x - x1;
			q = new_y - y1;

			//in = input.ptr<uchar>(y1) + x1 * channels;;
			//out = output.ptr<uchar>(y) + x * channels;
			for (int k = 0; k < 3; ++k)
			{
				output.at<Vec3b>(i, j)[k]=
										COLOR_RANGE(
						                (1-p) * (1-q) * input.at<Vec3b>(y1, x1)[k] +
										(p) * (1-q) * input.at<Vec3b>(y1,x1+1)[k]+
										(1-p) * (q) * input.at<Vec3b>(y1+1,x1)[k]+
										(p) * (q)* input.at<Vec3b>(y1+1,x1+1)[k]
						                 );
			}

		}
	}
	return 0;
}



} /* namespace cv */

【完整演示代码下载】

https://download.csdn.net/download/FL1623863129/88600785

【参考文献】

1 https://blog.csdn.net/c80486/article/details/52506429

码农张三疯
关注
专栏目录
opencv曝光算法_【OPENCV】高反差保留算法
weixin_42365804的博客
12-31 458
Tags: DIP高反差保留算法就是保留原图中反差比较大的地方，比如，一幅人脸图像中，反差比较大的地方就是五官了，在进行人脸美化的时候我们通常会对原图进行平滑处理，然而处理完之后丢失了图片的细节信息，因此在另一边我们通过会通过高反差保留或者其他高通滤波器保留图片的细节信息，然后将平滑之后的图像和高频图像进行光线性混合，可以得到更好的效果。具体到高反差保留算法，先使用高斯滤波器对图像进行平滑，高斯滤...
高反差保留滤镜学习OpenCV：滤镜系列（11）——高反差保留
weixin_34268843的博客
06-24 633
这几周笔者几篇文章介绍了改高反差保留滤镜的文章. 关联文章的地址     高反差保留就是高通滤波     r=(pix[x,y]-avg(R))/128     pix[x,y]*r+128*(1-r) #include &lt;math.h&gt; #include &lt;opencv/cv.h&gt; #include &lt;opencv/highgui.h&gt; us...
用OpenCV实现Photoshop算法(九): 高反差保留
09-11
用OpenCV实现Photoshop算法(九): 高反差保留
opencv 高反差保留算法
qianbo042311的博客
03-24 964
Mat HighPass(Mat img) { Mat temp; //GaussianBlur(img, temp, Size(3, 3), 1.6, 1.6); medianBlur(img, temp, 3); int r = 10; Mat diff = r * (img - temp); //高反差保留算法 return diff; }
学习OpenCV：滤镜系列（11）——高反差保留 （6.30修改版）
zhazhiqiang2010的专栏
11-25 2482
【原文：http://blog.csdn.net/yangtrees/article/details/9157749】 ============================================== 版权所有：小熊不去实验室CSDN博客 ============================================== 高反差保留就是高通
基于opencv实现photoshop算法高反差保留C++源码.7z
12-05
【测试环境】 vs2019 opencv==4.8.0 更多信息参考博文：https://blog.csdn.net/FL1623863129/article/details/141147282
C++opencv基于opencv实现photoshop算法色相和饱和度调整C++源码.7z
12-05
测试环境和效果演示参考博文：https://blog.csdn.net/FL1623863129/article/details/141147243
基于opencv实现photoshop算法色阶调整C++源码.7z
最新发布
08-12
测试环境和效果演示参考博文：https://blog.csdn.net/FL1623863129/article/details/141141238
opencv-photoshop-curves-用OpenCV实现Photoshop算法-曲线调整C++源码.rar
08-12
opencv_photoshop_curves-用OpenCV实现Photoshop算法-曲线调整C++源码.rar 博客地址：https://lw112190.blog.csdn.net/article/details/141137754
数字图像处理-高反差保留算法
云中寻雾的博客
08-16 1万+
高反差保留算法 高反差保留算法就是保留原图中反差比较大的地方，比如，一幅人脸图像中，反差比较大的地方就是五官了，在进行人脸美化的时候我们通常会对原图进行平滑处理，然而处理完之后丢失了图片的细节信息，因此在另一边我们通过会通过高反差保留或者其他高通滤波器保留图片的细节信息，然后将平滑之后的图像和高频图像进行光线性混合，可以得到更好的效果。 具体到高反差保留算法，先使用高斯滤波器对图像进行平滑，高斯...
图像处理技术及相应C++代码
CPFelix的博客
03-03 1003
1、直方图均衡化 //直方图均衡化 Mat equalizeHist_src; Mat imageRGB[3]; split(src, imageRGB); for (int i = 0; i < 3; i++) { equalizeHist(imageRGB[i], imageRGB[i]); } merge(imageRGB, 3, equalizeHist_src); //im...
opencv c++ 图像梯度、边缘、锐化
lucust的博客
11-30 5051
注：也可仿照robot算子示例输入3×3的卷积核，并赋予对应的sobel值进行梯度图像获取。分别使用x、y方向的算子来获取Gx，Gy，然后选用梯度计算方法来获取对应像素点的梯度值。获取图像上沿着某一方向或多个方向上，像素值的突变图像。分别为： 四邻域算子、八邻域算子、变种算子。即二阶导数的图像应用。之间相互独立的函数，
由Photoshop高反差保留算法原理联想到的一些图像增强算法。
weixin_34249367的博客
03-05 328
　　关于高反差保留的用处说明呢，从百度里复制了一段文字，我觉得写得蛮好的： 　　高反差保留就是保留图像的高反差部分，再说得真白些，就是保留图像上像素与周围反差比较大的部分，其它的部分都变为灰色。拿一个人物照片来举例，反差比较大的部分有人的眼睛，嘴，以及身体轮廓。如果执行了就反差保留，这些信息将留下来（与灰色形成鲜明对比）。它的主要作用就是加强图像中高反差部分。还以人物照片为例子，一般为了使人物皮...
[C++][原创]VSCode C++怎么让运行的时候弹出cmd窗口，而不是在VSCode调试输出
热门推荐
FL1623863129的博客
10-10 3万+
VSCode C++怎么让运行的时候弹出cmd窗口，而不是在VSCode调试输出？其实在VSCode调试输出是非常不错的，我很喜欢，但是偏偏有小白就喜欢每次运行弹个cmd窗口，这样的人也是少见。没办法，为了满足这样的小白的浪费时间的而且完全没有必要的要求，我研究了一下怎么让程序每次运行弹出一个cmd窗口。其实很简单只需要配置lauch.json即可，把"externalConsole":false 改成true，下面是一个完成是实例 { //使用IntelliSense了解相关属性。...
一文看懂MFC回调函数使用方法
FL1623863129的博客
07-22 6736
一直使用C#委托得心应手，但是扯到MFC或者C++委托就不太清楚了，今天特地研究下MFC回调函数，在网上找了一大堆资料，但是都讲得不清不楚，对于初学者还是不会用，不过幸好找到一篇文章，就是这唯一一篇文章我一下子明白了怎么用，有时候不需要具体清楚回调函数原理，但是必须得会使用才是关键，建议大家看下这篇文章https://blog.csdn.net/hwb506/article/details/663...
[C++][线程]如何利用std::thread把类的成员函数当作线程函数并传递参数
FL1623863129的博客
06-25 6072
然后我定义一个类A，我想把_start做为一个线程函数。大家仔细看看启动线程我在std::thread传递了3个参数,第一个就是函数，这里是类的成员函数_start，第二个类对象本身，第三个就是要传递给线程的参数。我在线程里面直接调用了A类的Say函数。（3）启动线程时候要传递三个对应参数，如果你线程函数是2个参数，则对应要传递4个参数给st::thread。（2）使用std::thread把类的成员函数作为线程函数，可以直接使用本类的成员函数。（1）类的函数要作为线程函数可以不用是static函数。
[C++]vector遍历方式4种
FL1623863129的博客
08-13 5556
/4.使用for_each()函数和Lambda表达式。//2.使用迭代器的for循环。//3.基于范围的for循环。//遍历容器的4种方法。//1.普通for循环。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农张三疯

你的打赏是我写文章最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值