仿Photoshop利用曲线对图像调整亮度与色彩

曲线调整是Photoshop的最常用的重要功能之一。对于一个RGB图像, 可以对R, G, B 通道进行独立的曲线调整,即,对三个通道分别使用三条曲线(Curve)。还可以再增加一条曲线对 三个通道进行整体调整。 因此,对一个图像,可以用四条曲线调整。最终的结果,是四条曲线调整后合并产生的结果。

图中,横轴是输入,比左到右分别表示0到255. 纵轴是输出,从下到上分别表示0到255.

具体代码分三个实现:

头文件 Curves.h

cpp 复制代码
/*
 * Adjust Curves
 */

#ifndef OPENCV2_PS_CURVES_HPP_
#define OPENCV2_PS_CURVES_HPP_
#include "opencv2/core.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
using namespace std;
using namespace cv;

namespace cv {

	/**
	 * Class of Curve for one channel
	 */
	class Curve {
	protected:
		Scalar color;
		Scalar back_color;
		int tolerance; //
		bool is_mouse_down;
		vector<Point> points;  //control points 
		vector<Point>::iterator current;  //pointer to current point

		vector<Point>::iterator  find(int x);
		vector<Point>::iterator  find(int x, int y);
		vector<Point>::iterator  add(int x, int y);

	public:
		Curve();
		virtual ~Curve();

		int calcCurve(double* z); //

		void draw(Mat& mat);  //
		void mouseDown(int x, int y); 
		bool mouseMove(int x, int y); 
		void mouseUp(int x, int y); 

		void clearPoints(); 
		int  addPoint(const Point& p); 
		int  deletePoint(const Point& p); 
		int  movePoint(const Point& p, int x, int y); 
	};

	/**
	 * Class of Curves for all channels
	 */
	class Curves {
	protected:
		void createColorTables(uchar colorTables[][256]);
	public:
		Curves();
		virtual ~Curves();

		Curve RGBChannel;   //RGB
		Curve RedChannel;   //Red
		Curve GreenChannel; //Green
		Curve BlueChannel;  //Blue

		Curve* CurrentChannel; 

		void draw(Mat& mat); 
		void mouseDown(int x, int y); 
		bool mouseMove(int x, int y);
		void mouseUp(int x, int y); 

	
		int adjust(InputArray src, OutputArray dst, InputArray mask = noArray());

	};
#endif/* OPENCV2_PS_CURVES_HPP_ */

	
	void dot_line(Mat& mat, Point& p1, Point& p2, Scalar& color, int step = 8);

} /* namespace cv */

Curves.cpp

cpp 复制代码
/*
 * Adjust Curves
 *
 */

#include "Curves.hpp"

#ifdef HAVE_OPENMP
#include <omp.h>
#endif

#define SWAP(a, b, t)  do { t = a; a = b; b = t; } while(0)
#define CLIP_RANGE(value, min, max)  ( (value) > (max) ? (max) : (((value) < (min)) ? (min) : (value)) )
#define COLOR_RANGE(value)  CLIP_RANGE((value), 0, 255)

#include <iostream>
#define DEBUG_PRINT(a)  cout << (a) << endl
#define PRINT_VAR(var)  cout << #var << " = " << (var) <<  endl

namespace cv {

	/**
	 * spline function
	 *
	 * @param x [in]  array of x-coordinate of control points
	 * @param y [in]  array of y-coordinate of control points
	 * @param n [in]  count of control points
	 * @param t [in]  array of x-coordinate of output points
	 * @param m [in]  count of output points
	 * @param z [out]  array of y-coordinate of output points
	 */
	static double spline(double* x, double* y, int n, double* t, int m, double* z)
	{
		double* dy = (double*)malloc(n * sizeof(int));
		memset(dy, 0, sizeof(double) * n);
		dy[0] = -0.5;

		//double* ddy = new double[n];
		double* ddy = (double*)malloc(n * sizeof(int));
		memset(ddy, 0, sizeof(double) * n);

		double h1;
		double* s = (double*)malloc(n * sizeof(int));
		double h0 = x[1] - x[0];

		s[0] = 3.0 * (y[1] - y[0]) / (2.0 * h0) - ddy[0] * h0 / 4.0;
		for (int j = 1; j <= n - 2; ++j)
		{
			h1 = x[j + 1] - x[j];
			double alpha = h0 / (h0 + h1);
			double beta = (1.0 - alpha) * (y[j] - y[j - 1]) / h0;
			beta = 3.0 * (beta + alpha * (y[j + 1] - y[j]) / h1);
			dy[j] = -alpha / (2.0 + (1.0 - alpha) * dy[j - 1]);
			s[j] = (beta - (1.0 - alpha) * s[j - 1]);
			s[j] = s[j] / (2.0 + (1.0 - alpha) * dy[j - 1]);
			h0 = h1;
		}
		dy[n - 1] = (3.0 * (y[n - 1] - y[n - 2]) / h1 + ddy[n - 1] * h1 / 2.0 - s[n - 2]) / (2.0 + dy[n - 2]);

		for (int j = n - 2; j >= 0; --j)
		{
			dy[j] = dy[j] * dy[j + 1] + s[j];
		}

		for (int j = 0; j <= n - 2; ++j)
		{
			s[j] = x[j + 1] - x[j];
		}

		for (int j = 0; j <= n - 2; ++j)
		{
			h1 = s[j] * s[j];
			ddy[j] = 6.0 * (y[j + 1] - y[j]) / h1 - 2.0 * (2.0 * dy[j] + dy[j + 1]) / s[j];
		}

		h1 = s[n - 2] * s[n - 2];
		ddy[n - 1] = 6.0 * (y[n - 2] - y[n - 1]) / h1 + 2.0 * (2.0 * dy[n - 1] + dy[n - 2]) / s[n - 2];
		double g = 0.0;
		for (int i = 0; i <= n - 2; i++)
		{
			h1 = 0.5 * s[i] * (y[i] + y[i + 1]);
			h1 = h1 - s[i] * s[i] * s[i] * (ddy[i] + ddy[i + 1]) / 24.0;
			g = g + h1;
		}

		for (int j = 0; j <= m - 1; j++)
		{
			int i;
			if (t[j] >= x[n - 1]) {
				i = n - 2;
			}
			else {
				i = 0;
				while (t[j] > x[i + 1]) {
					i = i + 1;
				}
			}
			h1 = (x[i + 1] - t[j]) / s[i];
			h0 = h1 * h1;
			z[j] = (3.0 * h0 - 2.0 * h0 * h1) * y[i];
			z[j] = z[j] + s[i] * (h0 - h0 * h1) * dy[i];
			h1 = (t[j] - x[i]) / s[i];
			h0 = h1 * h1;
			z[j] = z[j] + (3.0 * h0 - 2.0 * h0 * h1) * y[i + 1];
			z[j] = z[j] - s[i] * (h0 - h0 * h1) * dy[i + 1];
		}

		return(g);
	}

#define WITHIN(x1, delta, x2) ( (delta) > 0 ) ? ( (x1) <= (x2) ) : ( (x1) >= (x2) )
#define EXCEED(x1, delta, x2) ( (delta) > 0 ) ? ( (x1) >= (x2) ) : ( (x1) <= (x2) )

	void dot_line(Mat& mat, const Point& p1, const Point& p2, const Scalar& color,
		int thickness = 1, int lineType = 8, int line_step = 6, int blank_step = 6);

	void dot_line(Mat& mat, const Point& p1, const Point& p2, const Scalar& color,
		int thickness, int lineType, int line_step, int blank_step)
	{
		if (p1 == p2) return;

		//validate line_step
		line_step = ::abs(line_step);
		if (line_step == 0) line_step = 1;

		//validate blank_step
		blank_step = ::abs(blank_step);
		if (blank_step == 0) blank_step = 1;

		//dot_ratio = blank_step / line_step;
		double dot_ratio = blank_step * 1.0 / line_step;

		//calculat step_x, step_y
		double len, step_x, step_y;
		len = sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
		step_x = (p2.x - p1.x) / len * line_step;
		step_y = (p2.y - p1.y) / len * line_step;

		double x1, y1, x2, y2;
		x1 = p1.x;  y1 = p1.y;  //start from Point p1

		//draw line step by step, until meet Point p2
		if (::abs(p1.x - p2.x) > ::abs(p1.y - p2.y)) {
			//step in direction of x-coordination
			while (WITHIN(x1, step_x, p2.x)) {
				if (EXCEED(x1 + step_x * (1 + dot_ratio), step_x, p2.x)) {
					x2 = p2.x;
					y2 = p2.y;
				}
				else if (EXCEED(x1 + step_x, step_x, p2.x)) {
					x2 = p2.x;
					y2 = p2.y;
				}
				else {
					x2 = x1 + step_x;
					y2 = y1 + step_y;
				}
				line(mat, Point(x1, y1), Point(x2, y2), color, thickness, lineType);
				//step
				x1 = x2 + step_x * dot_ratio;
				y1 = y2 + step_y * dot_ratio;
			}

		}
		else {
			//step in direction of y-coordination
			while (WITHIN(y1, step_y, p2.y)) {
				if (EXCEED(y1 + step_y * (1 + dot_ratio), step_y, p2.y)) {
					x2 = p2.x;
					y2 = p2.y;
				}
				else if (EXCEED(y1 + step_y, step_y, p2.y)) {
					x2 = p2.x;
					y2 = p2.y;
				}
				else {
					x2 = x1 + step_x;
					y2 = y1 + step_y;
				}
				line(mat, Point(x1, y1), Point(x2, y2), color, thickness, lineType);
				//step
				x1 = x2 + step_x * dot_ratio;
				y1 = y2 + step_y * dot_ratio;
			}
		}
	}

	Curve::Curve()
	{
		color = Scalar(0, 0, 0);
		back_color = Scalar(255, 255, 255);
		tolerance = 3;
		is_mouse_down = false;
		points.push_back(Point(0, 0));
		points.push_back(Point(255, 255));
		current = points.end();
	}

	Curve::~Curve()
	{
	}


	vector<Point>::iterator  Curve::find(int x)
	{
		vector<Point>::iterator iter;
		for (iter = points.begin(); iter != points.end(); ++iter) {
			if (::abs(iter->x - x) <= tolerance)
				return iter;
		}
		return points.end();
	}

	vector<Point>::iterator  Curve::find(int x, int y)
	{
		vector<Point>::iterator iter;
		for (iter = points.begin(); iter != points.end(); ++iter) {
			if (::abs(iter->x - x) <= tolerance && ::abs(iter->y - y) <= tolerance)
				return iter;
		}
		return points.end();
	}

	vector<Point>::iterator Curve::add(int x, int y)
	{
		vector<Point>::iterator it = find(x);
		if (it == points.end()) {
			Point p(x, y);
			vector<Point>::iterator iter;
			for (iter = points.begin(); iter != points.end(); ++iter) {

				if (iter == points.begin() && iter->x > p.x) {
					DEBUG_PRINT("points insert at beginning");
					return points.insert(iter, p);
				}

				if (iter->x < x && (iter + 1) != points.end() && (iter + 1)->x > p.x) {
					DEBUG_PRINT("points insert");
					return points.insert(iter + 1, p);
				}
			}
			DEBUG_PRINT("points append");
			return points.insert(points.end(), p);
		}
		else {
			return it;
		}
	}

	int Curve::calcCurve(double* output_y)
	{
		//if count of control points is less than 2, return linear output
		if (points.size() < 2) {
			for (int i = 0; i < 256; ++i)
				output_y[i] = 255 - i;
			return 0;
		}

		//if count of control points is 2, return linear output
		if (points.size() == 2) {
			vector<Point>::iterator point1 = points.begin();
			vector<Point>::iterator point2 = point1 + 1;

			double delta_y = 0;
			if (point2->x != point1->x)
				delta_y = (point2->y - point1->y) * 1.0 / (point2->x - point1->x);

			//create output
			for (int i = 0; i < 256; ++i) {
				if (i < point1->x) {
					output_y[i] = point1->y;
				}
				else if (i >= point1->x && i < point2->x) {
					output_y[i] = COLOR_RANGE(point1->y + delta_y * (i - point1->x));
				}
				else {
					output_y[i] = point2->y;
				}
			}
			return 0;
		}


		//the count of control points is greater than 2,  create spline line
		int n = 0;
		n = points.size();  //count of points
		double* x = (double*)malloc(n * sizeof(int));
		double* y = (double*)malloc(n * sizeof(int));
		//create array of x-coordinate and y-coordinate of control points
		vector<Point>::iterator start_point = points.end();
		vector<Point>::iterator end_point = points.end();
		vector<Point>::iterator iter;
		int k = 0;
		for (iter = points.begin(); iter != points.end(); ++iter, ++k) {
			if (k == 0) start_point = iter;
			x[k] = iter->x - start_point->x;
			y[k] = iter->y;
			end_point = iter;
		}

		//if start_point or end_point is invalid
		if (start_point == points.end() || end_point == points.end() || start_point == end_point) {
			for (int i = 0; i < 256; ++i)
				output_y[i] = 255 - i;
			return 1;
		}

		//create array of x-coordinate of output points
		int m = end_point->x - start_point->x;
		double* t = (double*)malloc(n * sizeof(int));
		double* z = (double*)malloc(n * sizeof(int));
		//initialize array of x-coordinate
		for (int i = 0; i < m; ++i) {
			t[i] = i;
		}

		//perform spline, output y-coordinate is stored in array z
		spline(x, y, n, t, m, z);

		//create output
		for (int i = 0; i < 256; ++i) {
			if (i < start_point->x) {
				output_y[i] = start_point->y;
			}
			else if (i >= start_point->x && i < end_point->x) {
				output_y[i] = CLIP_RANGE(z[i - start_point->x], 0, 255);
			}
			else {
				output_y[i] = end_point->y;
			}
		}

		return 0;
	}

	void Curve::draw(Mat& mat)
	{
		int thinkness = 1;
		int n = 0;
		Point lastPoint;

		//clear background
		mat.setTo(back_color);

		vector<Point>::iterator it;
		for (it = points.begin(); it != points.end(); ++it) {
			cout << "point:  " << it->x << ", " << it->y << endl;
		}

		//draw lines
		dot_line(mat, Point(0, 0), Point(255, 0), Scalar(0, 0, 255), 1, 8, 4, 4);
		dot_line(mat, Point(0, 255), Point(255, 255), Scalar(0, 0, 255), 1, 8, 4, 4);

		dot_line(mat, Point(63, 0), Point(63, 255), color, 1, 8, 4, 4);
		dot_line(mat, Point(127, 0), Point(127, 255), color, 1, 8, 4, 4);
		dot_line(mat, Point(191, 0), Point(191, 255), color, 1, 8, 4, 4);
		dot_line(mat, Point(0, 255 - 63), Point(255, 255 - 63), color, 1, 8, 4, 4);
		dot_line(mat, Point(0, 255 - 127), Point(255, 255 - 127), color, 1, 8, 4, 4);
		dot_line(mat, Point(0, 255 - 191), Point(255, 255 - 191), color, 1, 8, 4, 4);

		//create curve
		double z[256];
		calcCurve(z);
		for (int i = 1; i < 256; ++i) {
			line(mat, Point(i - 1, 255 - z[i - 1]), Point(i, 255 - z[i]), color, 1, 8);
		}

		//draw control points
		vector<Point>::iterator iter, iter_next;
		for (iter = points.begin(); iter != points.end(); ++iter, ++n) {
			thinkness = (iter == current) ? -1 : 1;
			rectangle(mat, Point(iter->x - 2, 255 - iter->y + 2),
				Point(iter->x + 2, 255 - iter->y - 2), color, thinkness, 8);
		}
	}


	void Curve::mouseDown(int x, int y)
	{
		y = 255 - y;
		current = add(x, y);
		is_mouse_down = true;
	}

	bool  Curve::mouseMove(int x, int y)
	{
		y = 255 - y;
		if (is_mouse_down) {
			if (current != points.end()) {
				int prev_x = 0;
				int next_x = 255;

				if (current != points.begin()) {
					int prev_y = (current - 1)->y;
					prev_x = (current - 1)->x;

					//match the previous point
					if (points.size() > 2 && ::abs(x - prev_x) <= tolerance && ::abs(y - prev_y) <= tolerance) {
						current--;
						current = points.erase(current);
						DEBUG_PRINT("erase previous");
						return true;
					}

					//if x less than x of previou point
					if (x <= prev_x) {
						//DEBUG_PRINT("less than prev_x");
						return true;
					}
				}

				if ((current + 1) != points.end()) {
					int next_y = (current + 1)->y;
					next_x = (current + 1)->x;

					//match the next point
					if (points.size() > 2 && ::abs(x - next_x) <= tolerance && ::abs(y - next_y) <= tolerance) {
						current = points.erase(current);
						DEBUG_PRINT("erase next");
						return true;
					}

					//if x great than x of next point
					if (x >= next_x) {
						//DEBUG_PRINT("large than next_x");
						return true;
					}
				}

				current->x = CLIP_RANGE(x, 0, 255);
				current->y = CLIP_RANGE(y, 0, 255);

				return true;
			}
		}
		return false;
	}

	void Curve::mouseUp(int x, int y)
	{
		y = 255 - y;
		is_mouse_down = false;
	}


	void Curve::clearPoints()
	{
		points.clear();
	}

	int  Curve::addPoint(const Point& p)
	{
		vector<Point>::iterator iter = add(p.x, p.y);
		if (iter != points.end())
			return 1;
		else
			return 0;
	}

	int  Curve::deletePoint(const Point& p)
	{
		vector<Point>::iterator iter;
		iter = find(p.x, p.y);
		if (iter != points.end()) {
			if (current == iter)
				current = points.end();
			points.erase(iter);
			return 1;
		}
		return 0;
	}

	int  Curve::movePoint(const Point& p, int x, int y)
	{
		vector<Point>::iterator iter;
		iter = find(p.x, p.y);
		if (iter != points.end()) {
			iter->x = x;
			iter->y = y;
			return 1;
		}
		return 0;
	}


	//==========================================================
	// Curves

	Curves::Curves()
	{
		CurrentChannel = &RGBChannel;
	}

	Curves::~Curves()
	{
	}

	void Curves::draw(Mat& mat)
	{
		if (CurrentChannel)  CurrentChannel->draw(mat);
	}

	void Curves::mouseDown(int x, int y)
	{
		if (CurrentChannel)  CurrentChannel->mouseDown(x, y);
	}

	bool Curves::mouseMove(int x, int y)
	{
		if (CurrentChannel)
			return CurrentChannel->mouseMove(x, y);
		return false;
	}

	void Curves::mouseUp(int x, int y)
	{
		if (CurrentChannel)  CurrentChannel->mouseUp(x, y);
	}

	void Curves::createColorTables(uchar colorTables[][256])
	{
		double z[256];

		BlueChannel.calcCurve(z);
		for (int i = 0; i < 256; ++i) {
			colorTables[0][i] = z[i];
		}

		GreenChannel.calcCurve(z);
		for (int i = 0; i < 256; ++i)
			colorTables[1][i] = z[i];

		RedChannel.calcCurve(z);
		for (int i = 0; i < 256; ++i) {
			colorTables[2][i] = z[i];
		}

		uchar value;
		RGBChannel.calcCurve(z);
		for (int i = 0; i < 256; ++i) {
			for (int c = 0; c < 3; c++) {
				value = colorTables[c][i];
				colorTables[c][i] = z[value];
			}
		}
	}

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

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

		bool hasMask = true;
		Mat msk = mask.getMat();
		if (msk.empty())
			hasMask = false;

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

		uchar colorTables[3][256];

		//create color tables
		createColorTables(colorTables);

		//adjust each pixel

		if (hasMask) {
#ifdef HAVE_OPENMP
#pragma omp parallel for
#endif
			for (int y = 0; y < height; y++) {
				in = input.ptr<uchar>(y);
				out = output.ptr<uchar>(y);
				pmask = msk.ptr<uchar>(y);
				for (int x = 0; x < width; x++) {
					for (int c = 0; c < 3; c++) {
						*out = (colorTables[c][*in] * pmask[x] / 255.0)
							+ (*in) * (255 - pmask[x]) / 255.0;
						out++; in++;
					}
					for (int c = 0; c < channels - 3; c++) {
						*out++ = *in++;
					}
				}
			}
		}
		else {
#ifdef HAVE_OPENMP
#pragma omp parallel for
#endif
			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 c = 0; c < 3; c++) {
						*out++ = colorTables[c][*in++];
					}
					for (int c = 0; c < channels - 3; c++) {
						*out++ = *in++;
					}
				}
			}
		}

		return 0;
			}


		} /* namespace cv */

主函数main.cpp

cpp 复制代码
/*
 * test_Curves
 *
 */

#include <cstdio>
#include <iostream>
#include "opencv2/core.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include "Curves.hpp"

using namespace std;
using namespace cv;

static string window_name = "Photo";
static Mat src;

static string curves_window = "Adjust Curves";
static Mat curves_mat;
static int channel = 0;
Curves  curves;

static void invalidate()
{
	curves.draw(curves_mat);
	imshow(curves_window, curves_mat);

	Mat dst;
	curves.adjust(src, dst);
	imshow(window_name, dst);

	int y, x;
	uchar* p;

	y = 150; x = 50;
	p = dst.ptr<uchar>(y) + x * 3;
	cout << "(" << int(p[2]) << ", " << int(p[1]) << ", " << int(p[0]) << ")  ";

	y = 150; x = 220;
	p = dst.ptr<uchar>(y) + x * 3;
	cout << "(" << int(p[2]) << ", " << int(p[1]) << ", " << int(p[0]) << ")  ";

	y = 150; x = 400;
	p = dst.ptr<uchar>(y) + x * 3;
	cout << "(" << int(p[2]) << ", " << int(p[1]) << ", " << int(p[0]) << ")  " << endl;
}

static void callbackAdjustChannel(int, void*)
{
	switch (channel) {
	case 3:
		curves.CurrentChannel = &curves.BlueChannel;
		break;
	case 2:
		curves.CurrentChannel = &curves.GreenChannel;
		break;
	case 1:
		curves.CurrentChannel = &curves.RedChannel;
		break;
	default:
		curves.CurrentChannel = &curves.RGBChannel;
		break;
	}


	invalidate();
}

static void callbackMouseEvent(int mouseEvent, int x, int y, int flags, void* param)
{
	switch (mouseEvent) {
	case EVENT_LBUTTONDOWN:
		curves.mouseDown(x, y);
		invalidate();
		break;
	case EVENT_MOUSEMOVE:
		if (curves.mouseMove(x, y))
			invalidate();
		break;
	case EVENT_LBUTTONUP:
		curves.mouseUp(x, y);
		invalidate();
		break;
	}
	return;
}


int main()
{
	//read image file
	src = imread("center.jpg");
	if (!src.data) {
		cout << "error read image" << endl;
		return -1;
	}

	//create window
	namedWindow(window_name, WINDOW_NORMAL);
	resizeWindow(window_name, 800, 600);
	imshow(window_name, src);

	//create Mat for curves
	curves_mat = Mat::ones(256, 256, CV_8UC3);

	//create window for curves
	namedWindow(curves_window);
	setMouseCallback(curves_window, callbackMouseEvent, NULL);
	createTrackbar("Channel", curves_window, &channel, 3, callbackAdjustChannel);

	invalidate();


	waitKey();

	return 0;

}

代码是复制之后就能运行的,只要替换一下图像文件名。

1, Curves类中定义了四个Curve对象(即四个通道),分别是RedChannel, GreenChannel, BlueChannel 和 RGBChannel.

2, Curves类支持用鼠标生成曲线,使用方法见代码。

2, Curves.cpp中的spline()函数是生成曲线数值的,即输入一串控制点,通过插值运算,生成一系列的输出值。

3, 除了用鼠标生成曲线以外, 也可以用程序代码直接生成曲线:

先使用Curve类的clearPoints()方法清除所有控制点,再调用addPoint()方法逐个添加控制点即可。

相关推荐
李元豪3 小时前
【智鹿空间】c++实现了一个简单的链表数据结构 MyList,其中包含基本的 Get 和 Modify 操作,
数据结构·c++·链表
UestcXiye3 小时前
《TCP/IP网络编程》学习笔记 | Chapter 9:套接字的多种可选项
c++·计算机网络·ip·tcp
埃菲尔铁塔_CV算法4 小时前
图像算法之 OCR 识别算法:原理与应用场景
图像处理·python·计算机视觉
一丝晨光4 小时前
编译器、IDE对C/C++新标准的支持
c语言·开发语言·c++·ide·msvc·visual studio·gcc
丶Darling.4 小时前
Day40 | 动态规划 :完全背包应用 组合总和IV(类比爬楼梯)
c++·算法·动态规划·记忆化搜索·回溯
奶味少女酱~5 小时前
常用的c++特性-->day02
开发语言·c++·算法
我是哈哈hh5 小时前
专题十八_动态规划_斐波那契数列模型_路径问题_算法专题详细总结
c++·算法·动态规划
_小柏_6 小时前
C/C++基础知识复习(15)
c语言·c++
_oP_i7 小时前
cmake could not find a package configuration file provided by “Microsoft.GSL“
c++
mingshili7 小时前
[python] 如何debug python脚本中C++后端的core dump
c++·python·debug