OpenCV实现Photoshop算法-曲线调整

目录

效果

代码

demo.cpp

Curves.hpp

Curves.cpp

参考

下载

效果

OpenCV实现Photoshop算法-曲线调整-效果

代码

demo.cpp

/*
 * test_Curves
 */

#include
#include
#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(y) + x * 3;
    cout << "(" << int(p[2]) << ", " << int(p[1]) << ", " << int(p[0]) << ")  ";

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

    y = 150; x = 400;
    p = dst.ptr(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("building.jpg");
    if (!src.data) {
        cout << "error read image" << endl;
        return -1;
    }

    //create window
    namedWindow(window_name);
    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);


    // 范例：用程序代码在Red通道中定义一条曲线
    //    curves.RedChannel.clearPoints();
    //    curves.RedChannel.addPoint( Point(10,  10) );
    //    curves.RedChannel.addPoint( Point(240, 240) );
    //    curves.RedChannel.addPoint( Point(127, 127) );

    invalidate();


    waitKey();

    return 0;

}
 

  1. /*
  2.  * test_Curves
  3.  */
  5. #include <cstdio>
  6. #include <iostream>
  7. #include "opencv2/core.hpp"
  8. #include "opencv2/imgproc.hpp"
  9. #include "opencv2/highgui.hpp"
  10. #include "Curves.hpp"
  11.  
  12. using namespace std;
  13. using namespace cv;
  14.  
  15. static string window_name = "Photo";
  16. static Mat src;
  17.  
  18. static string curves_window = "Adjust Curves";
  19. static Mat curves_mat;
  20. static int channel = 0;
  21. Curves  curves;
  22.  
  23. static void invalidate()
  24. {
  25. 	curves.draw(curves_mat);
  26. 	imshow(curves_window, curves_mat);
  27.  
  28. 	Mat dst;
  29. 	curves.adjust(src, dst);
  30. 	imshow(window_name, dst);
  31.  
  32. 	int y, x;
  33. 	uchar* p;
  34.  
  35. 	y = 150; x = 50;
  36. 	p = dst.ptr<uchar>(y) + x * 3;
  37. 	cout << "(" << int(p[2]) << ", " << int(p[1]) << ", " << int(p[0]) << ")  ";
  38.  
  39. 	y = 150; x = 220;
  40. 	p = dst.ptr<uchar>(y) + x * 3;
  41. 	cout << "(" << int(p[2]) << ", " << int(p[1]) << ", " << int(p[0]) << ")  ";
  42.  
  43. 	y = 150; x = 400;
  44. 	p = dst.ptr<uchar>(y) + x * 3;
  45. 	cout << "(" << int(p[2]) << ", " << int(p[1]) << ", " << int(p[0]) << ")  " << endl;
  46. }
  47.  
  48. static void callbackAdjustChannel(int, void*)
  49. {
  50. 	switch (channel) {
  51. 	case 3:
  52. 		curves.CurrentChannel = &curves.BlueChannel;
  53. 		break;
  54. 	case 2:
  55. 		curves.CurrentChannel = &curves.GreenChannel;
  56. 		break;
  57. 	case 1:
  58. 		curves.CurrentChannel = &curves.RedChannel;
  59. 		break;
  60. 	default:
  61. 		curves.CurrentChannel = &curves.RGBChannel;
  62. 		break;
  63. 	}
  64.  
  65.  
  66. 	invalidate();
  67. }
  68.  
  69. static void callbackMouseEvent(int mouseEvent, int x, int y, int flags, void* param)
  70. {
  71. 	switch (mouseEvent) {
  72. 	case  EVENT_LBUTTONDOWN:
  73. 		curves.mouseDown(x, y);
  74. 		invalidate();
  75. 		break;
  76. 	case EVENT_MOUSEMOVE:
  77. 		if (curves.mouseMove(x, y))
  78. 			invalidate();
  79. 		break;
  80. 	case EVENT_LBUTTONUP:
  81. 		curves.mouseUp(x, y);
  82. 		invalidate();
  83. 		break;
  84. 	}
  85. 	return;
  86. }
  87.  
  88.  
  89. int main()
  90. {
  91. 	//read image file
  92. 	src = imread("building.jpg");
  93. 	if (!src.data) {
  94. 		cout << "error read image" << endl;
  95. 		return -1;
  96. 	}
  97.  
  98. 	//create window
  99. 	namedWindow(window_name);
  100. 	imshow(window_name, src);
  101.  
  102. 	//create Mat for curves
  103. 	curves_mat = Mat::ones(256, 256, CV_8UC3);
  104.  
  105. 	//create window for curves
  106. 	namedWindow(curves_window);
  107. 	setMouseCallback(curves_window, callbackMouseEvent, NULL);
  108. 	createTrackbar("Channel", curves_window, &channel, 3, callbackAdjustChannel);
  109.  
  110.  
  111. 	// 范例：用程序代码在Red通道中定义一条曲线
  112. 	//	curves.RedChannel.clearPoints();
  113. 	//	curves.RedChannel.addPoint( Point(10,  10) );
  114. 	//	curves.RedChannel.addPoint( Point(240, 240) );
  115. 	//	curves.RedChannel.addPoint( Point(127, 127) );
  116.  
  117. 	invalidate();
  118.  
  119.  
  120. 	waitKey();
  121.  
  122. 	return 0;
  123.  
  124. }

Curves.hpp

  1. /*
  2.  * Adjust Curves
  3.  */
  5. #ifndef OPENCV2_PS_CURVES_HPP_
  6. #define OPENCV2_PS_CURVES_HPP_
  7.  
  8. #include "opencv2/core.hpp"
  9. #include "opencv2/imgproc.hpp"
  10. #include "opencv2/highgui.hpp"
  11. using namespace std;
  12. using namespace cv;
  13.  
  14. namespace cv {
  15.  
  16. /**
  17.  * Class of Curve for one channel
  18.  */
  19. class Curve {
  20. protected:
  21. 	Scalar color;
  22. 	Scalar back_color;
  23. 	int tolerance; //鼠标按下或移动时，捕获曲线点的误差范围
  24. 	bool is_mouse_down;
  25. 	vector<Point> points;  //control points 曲线的所有控制点
  26. 	vector<Point>::iterator current;  //pointer to current point 当前控制点的指针
  27.  
  28. 	vector<Point>::iterator  find(int x);
  29. 	vector<Point>::iterator  find(int x, int y);
  30. 	vector<Point>::iterator  add(int x, int y);
  31.  
  32. public:
  33. 	Curve();
  34. 	virtual ~Curve();
  35.  
  36. 	int calcCurve(double *z); //供内部调用的方法：计算曲线
  37.  
  38. 	void draw(Mat &mat);  //将曲线画在mat上
  39. 	void mouseDown(int x, int y); //当鼠标按下，请调用mouseDown()方法
  40. 	bool mouseMove(int x, int y); //当鼠标移动，请调用mouseMove()方法
  41. 	void mouseUp(int x, int y); //当鼠标抬起，请调用mouseUp()方法
  42.  
  43. 	//以下方法用于：用编程方式生成曲线
  44. 	void clearPoints(); //清除曲线上所有的点
  45. 	int  addPoint(const Point &p); //增加一个点
  46. 	int  deletePoint(const Point &p); //删除一个点
  47. 	int  movePoint(const Point &p, int x, int y); //移动一个点
  48. };
  49.  
  50. /**
  51.  * Class of Curves for all channels
  52.  */
  53. class Curves {
  54. protected:
  55. 	void createColorTables(uchar colorTables[][256]);
  56. public:
  57. 	Curves();
  58. 	virtual ~Curves();
  59.  
  60. 	Curve RGBChannel;   //RGB总通道
  61. 	Curve RedChannel;   //Red通道
  62. 	Curve GreenChannel; //Green通道
  63. 	Curve BlueChannel;  //Blue通道
  64.  
  65. 	Curve * CurrentChannel; //当前通道的指针
  66.  
  67. 	void draw(Mat &mat);  //将曲线画在mat上
  68. 	void mouseDown(int x, int y); //当鼠标按下，请调用mouseDown()方法
  69. 	bool mouseMove(int x, int y); //当鼠标移动，请调用mouseMove()方法
  70. 	void mouseUp(int x, int y); //当鼠标抬起，请调用mouseUp()方法
  71.  
  72. 	//实施曲线调整
  73. 	int adjust(InputArray src, OutputArray dst, InputArray mask = noArray());
  74.  
  75. };
  76.  
  77. //画一条虚线
  78. void dot_line(Mat &mat, Point &p1, Point &p2, Scalar &color, int step = 8);
  79.  
  80. } /* namespace cv */
  81.  
  82. #endif /* OPENCV2_PS_CURVES_HPP_ */

Curves.cpp

  1. #include "Curves.hpp"
  2.  
  3. #ifdef HAVE_OPENMP
  4. #include <omp.h>
  5. #endif
  6.  
  7. #define SWAP(a, b, t)  do { t = a; a = b; b = t; } while(0)
  8. #define CLIP_RANGE(value, min, max)  ( (value) > (max) ? (max) : (((value) < (min)) ? (min) : (value)) )
  9. #define COLOR_RANGE(value)  CLIP_RANGE((value), 0, 255)
  10.  
  11. #include <iostream>
  12. #define DEBUG_PRINT(a)  cout << (a) << endl
  13. #define PRINT_VAR(var)  cout << #var << " = " << (var) <<  endl
  14.  
  15. namespace cv {
  16.  
  17. /**
  18.  * spline function
  19.  *
  20.  * @param x [in]  array of x-coordinate of control points
  21.  * @param y [in]  array of y-coordinate of control points
  22.  * @param n [in]  count of control points
  23.  * @param t [in]  array of x-coordinate of output points
  24.  * @param m [in]  count of output points
  25.  * @param z [out]  array of y-coordinate of output points
  26.  */
  27. static double spline(double *x, double *y, int n, double *t, int m, double *z)
  28. {
  29.     double* dy = new double[n];
  30.     memset(dy, 0, sizeof(double)*n);
  31.     dy[0] = -0.5;
  32.  
  33.     double* ddy = new double[n];
  34.     memset(ddy, 0, sizeof(double)*n);
  35.  
  36.     double h1;
  37.     double* s = new double[n];
  38.     double h0 = x[1] - x[0];
  39.  
  40.     s[0] = 3.0 * (y[1] - y[0]) / (2.0 * h0) - ddy[0] * h0 / 4.0;
  41.     for( int j = 1; j <= n - 2; ++j )
  42.     {
  43.         h1 = x[j + 1] - x[j];
  44.         double alpha = h0 / (h0 + h1);
  45.         double beta = (1.0 - alpha) * (y[j] - y[j - 1]) / h0;
  46.         beta = 3.0 * (beta + alpha * ( y[j + 1] - y[j] ) / h1);
  47.         dy[j] = -alpha / (2.0 + (1.0 - alpha) * dy[j - 1]);
  48.         s[j] = (beta - (1.0 - alpha) * s[j - 1]);
  49.         s[j] = s[j] / (2.0 + (1.0 - alpha) * dy[j - 1]);
  50.         h0 = h1;
  51.     }
  52.     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]);
  53.  
  54.     for( int j = n - 2; j >= 0; --j )
  55.     {
  56.         dy[j] = dy[j] * dy[j + 1] + s[j];
  57.     }
  58.  
  59.     for( int j = 0; j <= n - 2; ++j )
  60.     {
  61.         s[j] = x[j + 1] - x[j];
  62.     }
  63.  
  64.     for( int j = 0; j <= n - 2; ++j )
  65.     {
  66.         h1 = s[j] * s[j];
  67.         ddy[j] = 6.0 * (y[j+1] - y[j]) / h1 - 2.0 * (2.0 * dy[j] + dy[j+1]) / s[j];
  68.     }
  69.  
  70.     h1 = s[n-2] * s[n-2];
  71.     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];
  72.     double g = 0.0;
  73.     for(int i=0; i<=n-2; i++)
  74.     {
  75.         h1 = 0.5 * s[i] * (y[i] + y[i+1]);
  76.         h1 = h1 - s[i] * s[i] * s[i] * (ddy[i] + ddy[i+1]) / 24.0;
  77.         g = g + h1;
  78.     }
  79.  
  80.     for(int j=0; j<=m-1; j++)
  81.     {
  82.         int i;
  83.         if( t[j] >= x[n-1] ) {
  84.             i = n - 2;
  85.         } else {
  86.             i = 0;
  87.             while(t[j] > x[i+1]) {
  88.                 i = i + 1;
  89.             }
  90.         }
  91.         h1 = (x[i+1] - t[j]) / s[i];
  92.         h0 = h1 * h1;
  93.         z[j] = (3.0 * h0 - 2.0 * h0 * h1) * y[i];
  94.         z[j] = z[j] + s[i] * (h0 - h0 * h1) * dy[i];
  95.         h1 = (t[j] - x[i]) / s[i];
  96.         h0 = h1 * h1;
  97.         z[j] = z[j] + (3.0 * h0 - 2.0 * h0 * h1) * y[i+1];
  98.         z[j] = z[j] - s[i] * (h0 - h0 * h1) * dy[i+1];
  99.     }
  100.  
  101.     delete [] s;
  102.     delete [] dy;
  103.     delete [] ddy;
  104.  
  105.     return(g);
  106. }
  107.  
  108. #define WITHIN(x1, delta, x2) ( (delta) > 0 ) ? ( (x1) <= (x2) ) : ( (x1) >= (x2) )
  109. #define EXCEED(x1, delta, x2) ( (delta) > 0 ) ? ( (x1) >= (x2) ) : ( (x1) <= (x2) )
  110.  
  111. void dot_line(Mat &mat, const Point &p1, const Point &p2,  const Scalar &color,
  112.   int thickness = 1, int lineType = 8, int line_step = 6, int blank_step = 6 );
  113.  
  114. void dot_line(Mat &mat, const Point &p1, const Point &p2,  const Scalar &color,
  115.   int thickness, int lineType, int line_step, int blank_step )
  116. {
  117.  if ( p1 == p2 ) return;
  118.  
  119.  //validate line_step
  120.  line_step = ::abs(line_step);
  121.  if ( line_step == 0 ) line_step = 1;
  122.  
  123.  //validate blank_step
  124.  blank_step = ::abs(blank_step);
  125.  if ( blank_step == 0 ) blank_step = 1;
  126.  
  127.  //dot_ratio = blank_step / line_step;
  128.  double dot_ratio = blank_step * 1.0 / line_step;
  129.  
  130.  //calculat step_x, step_y
  131.  double len, step_x, step_y;
  132.  len = sqrt( (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y) );
  133.  step_x = (p2.x - p1.x) / len  * line_step;
  134.  step_y = (p2.y - p1.y) / len  * line_step;
  135.  
  136.  double x1, y1, x2, y2;
  137.  x1 = p1.x;  y1 = p1.y;  //start from Point p1
  138.  
  139.  //draw line step by step, until meet Point p2
  140.  if ( ::abs(p1.x - p2.x) > ::abs(p1.y - p2.y) ) {
  141.   //step in direction of x-coordination
  142.   while ( WITHIN(x1, step_x, p2.x) ) {
  143.    if ( EXCEED(x1 + step_x * (1 + dot_ratio), step_x, p2.x )) {
  144.     x2 = p2.x;
  145.     y2 = p2.y;
  146.    } else if ( EXCEED(x1 + step_x, step_x, p2.x )) {
  147.     x2 = p2.x;
  148.     y2 = p2.y;
  149.    } else {
  150.     x2 = x1 + step_x;
  151.     y2 = y1 + step_y;
  152.    }
  153.    line(mat, Point(x1, y1), Point(x2, y2), color, thickness, lineType);
  154.    //step
  155.    x1 = x2 + step_x * dot_ratio;
  156.    y1 = y2 + step_y * dot_ratio;
  157.   }
  158.  
  159.  } else {
  160.   //step in direction of y-coordination
  161.   while ( WITHIN(y1, step_y, p2.y) ) {
  162.    if ( EXCEED(y1 + step_y * (1 + dot_ratio), step_y, p2.y )) {
  163.     x2 = p2.x;
  164.     y2 = p2.y;
  165.    } else if ( EXCEED(y1 + step_y, step_y, p2.y )) {
  166.     x2 = p2.x;
  167.     y2 = p2.y;
  168.    } else {
  169.     x2 = x1 + step_x;
  170.     y2 = y1 + step_y;
  171.    }
  172.    line(mat, Point(x1, y1), Point(x2, y2), color, thickness, lineType);
  173.    //step
  174.    x1 = x2 + step_x * dot_ratio;
  175.    y1 = y2 + step_y * dot_ratio;
  176.   }
  177.  }
  178. }
  179.  
  180. Curve::Curve()
  181. {
  182.  color = Scalar(0,0,0);
  183.  back_color = Scalar(255,255,255);
  184.  tolerance = 3;
  185.  is_mouse_down = false;
  186.  points.push_back( Point(0, 0) );
  187.  points.push_back( Point(255, 255) );
  188.  current = points.end();
  189. }
  190.  
  191. Curve::~Curve()
  192. {
  193. }
  194.  
  195.  
  196. vector<Point>::iterator  Curve::find(int x)
  197. {
  198.  vector<Point>::iterator iter;
  199.  for (iter = points.begin(); iter != points.end(); ++iter ) {
  200.   if ( ::abs(iter->x - x ) <= tolerance )
  201.    return iter;
  202.  }
  203.  return points.end();
  204. }
  205.  
  206. vector<Point>::iterator  Curve::find(int x, int y)
  207. {
  208.  vector<Point>::iterator iter;
  209.  for (iter = points.begin(); iter != points.end(); ++iter ) {
  210.   if ( ::abs(iter->x - x ) <= tolerance && ::abs(iter->y - y ) <= tolerance )
  211.    return iter;
  212.  }
  213.  return points.end();
  214. }
  215.  
  216. vector<Point>::iterator Curve::add(int x, int y)
  217. {
  218.  vector<Point>::iterator it = find(x);
  219.  if ( it == points.end() ) {
  220.   Point p(x, y);
  221.   vector<Point>::iterator iter;
  222.   for (iter = points.begin(); iter != points.end(); ++iter ) {
  223.  
  224.    if ( iter == points.begin() && iter->x > p.x) {
  225.     DEBUG_PRINT("points insert at beginning");
  226.     return points.insert( iter, p );
  227.    }
  228.  
  229.    if ( iter->x < x &&  (iter + 1) != points.end() &&  (iter + 1)->x > p.x) {
  230.     DEBUG_PRINT("points insert");
  231.     return points.insert( iter + 1, p );
  232.    }
  233.   }
  234.   DEBUG_PRINT("points append");
  235.   return points.insert( points.end(), p );
  236.  } else {
  237.   return it;
  238.  }
  239. }
  240.  
  241. int Curve::calcCurve(double *output_y)
  242. {
  243.  //if count of control points is less than 2, return linear output
  244.  if ( points.size() < 2) {
  245.   for (int i = 0; i < 256; ++i )
  246.    output_y[i] = 255 - i;
  247.   return 0;
  248.  }
  249.  
  250.  //if count of control points is 2, return linear output
  251.  if ( points.size() == 2 ) {
  252.   vector<Point>::iterator point1 = points.begin();
  253.   vector<Point>::iterator point2 = point1 + 1;
  254.  
  255.   double delta_y = 0;
  256.   if ( point2->x != point1->x )
  257.    delta_y  = (point2->y - point1->y) * 1.0 / (point2->x - point1->x);
  258.  
  259.   //create output
  260.   for ( int i = 0; i < 256; ++i ) {
  261.    if ( i < point1->x ) {
  262.     output_y[i] = point1->y;
  263.    } else if ( i >= point1->x && i < point2->x ) {
  264.     output_y[i] = COLOR_RANGE( point1->y + delta_y * (i - point1->x) );
  265.    } else {
  266.     output_y[i] = point2->y;
  267.    }
  268.   }
  269.   return 0;
  270.  }
  271.  
  272.  
  273.  //the count of control points is greater than 2,  create spline line
  274.  
  275.  int n = points.size();  //count of points
  276.  
  277.  //create array of x-coordinate and y-coordinate of control points
  278.  //double x[ n ];
  279.  //double y[ n ];
  280.  double* x = new double[n];
  281.  double* y = new double[n];
  282.  
  283.  vector<Point>::iterator start_point = points.end();
  284.  vector<Point>::iterator end_point = points.end();
  285.     vector<Point>::iterator iter;
  286.     int k = 0;
  287.     for (iter = points.begin(); iter != points.end(); ++iter, ++k ) {
  288.      if ( k == 0 ) start_point = iter;
  289.      x[k] = iter->x - start_point->x;
  290.      y[k] = iter->y;
  291.      end_point = iter;
  292.     }
  293.  
  294.     //if start_point or end_point is invalid
  295.     if (start_point == points.end() || end_point == points.end() || start_point == end_point) {
  296.      for (int i = 0; i < 256; ++i )
  297.       output_y[i] = 255 - i;
  298.      return 1;
  299.     }
  300.  
  301.     //create array of x-coordinate of output points
  302.  int m = end_point->x - start_point->x;
  303.  //double t[m];  //array of x-coordinate of output points
  304.  //double z[m];  //array of y-coordinate of output points
  305.  
  306.  double* t = new double[m];
  307.  double* z = new double[m];
  308.  
  309.  //initialize array of x-coordinate
  310.  for ( int i = 0; i< m; ++i ) {
  311.   t[i] = i;
  312.  }
  313.  
  314.  //perform spline, output y-coordinate is stored in array z
  315.  spline(x, y, n, t, m, z);
  316.  
  317.  //create output
  318.  for ( int i = 0; i < 256; ++i ) {
  319.   if ( i < start_point->x ) {
  320.    output_y[i] = start_point->y;
  321.   } else if ( i >= start_point->x && i < end_point->x ) {
  322.    output_y[i] = CLIP_RANGE(z[i - start_point->x], 0, 255);
  323.   } else {
  324.    output_y[i] = end_point->y;
  325.   }
  326.  }
  327.  
  328.  delete[] t;
  329.  delete[] z;
  330.  delete[] x;
  331.  delete[] y;
  332.  
  333.  return 0;
  334. }
  335.  
  336. void Curve::draw(Mat &mat)
  337. {
  338.  int thinkness = 1;
  339.  int n = 0;
  340.  Point lastPoint;
  341.  
  342.  //clear background
  343.  mat.setTo( back_color );
  344.  
  345.  vector<Point>::iterator it;
  346.  for (it = points.begin(); it != points.end(); ++it) {
  347.   cout << "point:  "<< it->x << ", " << it->y << endl;
  348.  }
  349.  
  350.  //draw lines
  351.  dot_line(mat, Point( 0, 0), Point( 255, 0), Scalar(0,0,255), 1, 8, 4, 4);
  352.  dot_line(mat, Point( 0, 255), Point( 255, 255), Scalar(0,0,255), 1, 8, 4, 4);
  353.  
  354.  dot_line(mat, Point(63, 0), Point(63, 255), color, 1, 8, 4, 4);
  355.  dot_line(mat, Point(127, 0), Point(127, 255), color, 1, 8, 4, 4);
  356.  dot_line(mat, Point(191, 0), Point(191, 255), color, 1, 8, 4, 4);
  357.  dot_line(mat, Point(0,  255 - 63), Point(255,  255 - 63), color, 1, 8, 4, 4);
  358.  dot_line(mat, Point(0, 255 - 127), Point(255, 255 - 127), color, 1, 8, 4, 4);
  359.  dot_line(mat, Point(0, 255 - 191), Point(255, 255 - 191), color, 1, 8, 4, 4);
  360.  
  361.  //create curve
  362.  double z[256];
  363.  calcCurve(z);
  364.  for (int i = 1; i < 256; ++i ) {
  365.   line( mat, Point(i-1, 255 - z[i-1]), Point(i, 255 - z[i]), color, 1, 8 );
  366.  }
  367.  
  368.  //draw control points
  369.  vector<Point>::iterator iter, iter_next;
  370.  for (iter = points.begin(); iter != points.end(); ++iter, ++n ) {
  371.   thinkness = (iter == current) ? -1 : 1;
  372.   rectangle(mat, Point(iter->x - 2, 255 - iter->y + 2),
  373.     Point(iter->x + 2, 255 - iter->y - 2), color, thinkness, 8);
  374.  }
  375. }
  376.  
  377.  
  378. void Curve::mouseDown(int x, int y)
  379. {
  380.  y = 255 - y;
  381.  current = add( x , y );
  382.  is_mouse_down = true;
  383. }
  384.  
  385. bool  Curve::mouseMove(int x, int y)
  386. {
  387.  y = 255 - y;
  388.  if ( is_mouse_down ) {
  389.   if (current != points.end()) {
  390.    int prev_x = 0;
  391.    int next_x = 255;
  392.  
  393.    if (current != points.begin()) {
  394.     int prev_y = (current - 1)->y;
  395.     prev_x = (current - 1)->x;
  396.  
  397.     //match the previous point
  398.     if ( points.size() > 2 && ::abs(x - prev_x) <= tolerance && ::abs(y - prev_y) <= tolerance ) {
  399.      current--;
  400.      current = points.erase(current);
  401.      DEBUG_PRINT("erase previous");
  402.      return true;
  403.     }
  404.  
  405.     //if x less than x of previou point
  406.     if ( x <= prev_x) {
  407.      //DEBUG_PRINT("less than prev_x");
  408.      return true;
  409.     }
  410.    }
  411.  
  412.    if ( ( current + 1) != points.end()) {
  413.     int next_y = (current + 1)->y;
  414.     next_x = (current + 1)->x;
  415.  
  416.     //match the next point
  417.     if ( points.size() > 2 && ::abs(x - next_x) <= tolerance && ::abs(y - next_y) <= tolerance ) {
  418.      current = points.erase(current);
  419.      DEBUG_PRINT("erase next");
  420.      return true;
  421.     }
  422.  
  423.     //if x great than x of next point
  424.     if ( x >= next_x) {
  425.      //DEBUG_PRINT("large than next_x");
  426.      return true;
  427.     }
  428.    }
  429.  
  430.    current->x = CLIP_RANGE(x, 0, 255);
  431.    current->y = CLIP_RANGE(y, 0, 255);
  432.  
  433.    return true;
  434.   }
  435.  }
  436.  return false;
  437. }
  438.  
  439. void Curve::mouseUp(int x, int y)
  440. {
  441.  y = 255 - y;
  442.  is_mouse_down = false;
  443. }
  444.  
  445.  
  446. void Curve::clearPoints()
  447. {
  448.  points.clear();
  449. }
  450.  
  451. int  Curve::addPoint(const Point &p)
  452. {
  453.  vector<Point>::iterator iter = add(p.x, p.y);
  454.  if ( iter != points.end() )
  455.   return 1;
  456.  else
  457.   return 0;
  458. }
  459.  
  460. int  Curve::deletePoint(const Point &p)
  461. {
  462.  vector<Point>::iterator iter;
  463.  iter = find( p.x, p.y );
  464.  if ( iter != points.end() ) {
  465.   if ( current == iter )
  466.    current = points.end();
  467.   points.erase(iter);
  468.   return 1;
  469.  }
  470.  return 0;
  471. }
  472.  
  473. int  Curve::movePoint(const Point &p, int x, int y)
  474. {
  475.  vector<Point>::iterator iter;
  476.  iter = find( p.x, p.y );
  477.  if ( iter != points.end() ) {
  478.   iter->x = x;
  479.   iter->y = y;
  480.   return 1;
  481.  }
  482.  return 0;
  483. }
  484.  
  485.  
  486. //=========================================================
  487. // Curves
  488.  
  489. Curves::Curves()
  490. {
  491.  CurrentChannel = &RGBChannel;
  492. }
  493.  
  494. Curves::~Curves()
  495. {
  496. }
  497.  
  498. void Curves::draw(Mat &mat)
  499. {
  500.  if (CurrentChannel)  CurrentChannel->draw(mat);
  501. }
  502.  
  503. void Curves::mouseDown(int x, int y)
  504. {
  505.  if (CurrentChannel)  CurrentChannel->mouseDown(x, y);
  506. }
  507.  
  508. bool Curves::mouseMove(int x, int y)
  509. {
  510.  if (CurrentChannel)
  511.   return CurrentChannel->mouseMove(x, y);
  512.  return false;
  513. }
  514.  
  515. void Curves::mouseUp(int x, int y)
  516. {
  517.  if (CurrentChannel)  CurrentChannel->mouseUp(x, y);
  518. }
  519.  
  520. void Curves::createColorTables(uchar colorTables[][256])
  521. {
  522.  double z[256];
  523.  
  524.  BlueChannel.calcCurve(z);
  525.  for (int i = 0; i < 256; ++i ) {
  526.   colorTables[0][i] = z[i];
  527.  }
  528.  
  529.  GreenChannel.calcCurve(z);
  530.  for (int i = 0; i < 256; ++i )
  531.   colorTables[1][i] = z[i];
  532.  
  533.  RedChannel.calcCurve(z);
  534.  for (int i = 0; i < 256; ++i ) {
  535.   colorTables[2][i] = z[i];
  536.  }
  537.  
  538.  uchar value;
  539.  RGBChannel.calcCurve(z);
  540.  for (int i = 0; i < 256; ++i ) {
  541.   for (int c = 0; c < 3; c++ ) {
  542.    value = colorTables[c][i];
  543.    colorTables[c][i] = z[value];
  544.   }
  545.  }
  546. }
  547.  
  548. int Curves::adjust(InputArray src, OutputArray dst, InputArray mask)
  549. {
  550.  Mat input = src.getMat();
  551.  if( input.empty() ) {
  552.   return -1;
  553.  }
  554.  
  555.  dst.create(src.size(), src.type());
  556.  Mat output = dst.getMat();
  557.  
  558.  bool hasMask = true;
  559.  Mat msk = mask.getMat();
  560.  if (msk.empty())
  561.   hasMask = false;
  562.  
  563.  const uchar *in;
  564.  const uchar *pmask;
  565.  uchar *out;
  566.  int width = input.cols;
  567.  int height = input.rows;
  568.  int channels = input.channels();
  569.  
  570.  uchar colorTables[3][256];
  571.  
  572.  //create color tables
  573.  createColorTables( colorTables );
  574.  
  575.  //adjust each pixel
  576.  
  577.  if ( hasMask ) {
  578.   #ifdef HAVE_OPENMP
  579.   #pragma omp parallel for
  580.   #endif
  581.   for (int y = 0; y < height; y ++) {
  582.    in = input.ptr<uchar>(y);
  583.    out = output.ptr<uchar>(y);
  584.    pmask = msk.ptr<uchar>(y);
  585.    for (int x = 0; x < width; x ++) {
  586.     for (int c = 0; c < 3; c++) {
  587.      *out = (colorTables[c][*in] * pmask[x] / 255.0)
  588.        + (*in) * (255 - pmask[x]) / 255.0;
  589.      out++; in++;
  590.     }
  591.     for (int c = 0; c < channels - 3; c++) {
  592.      *out++ = *in++;
  593.     }
  594.    }
  595.   }
  596.  } else {
  597.   #ifdef HAVE_OPENMP
  598.   #pragma omp parallel for
  599.   #endif
  600.   for (int y = 0; y < height; y ++) {
  601.    in = input.ptr<uchar>(y);
  602.    out = output.ptr<uchar>(y);
  603.    for (int x = 0; x < width; x ++) {
  604.     for (int c = 0; c < 3; c++) {
  605.      *out++ = colorTables[c][*in++];
  606.     }
  607.     for (int c = 0; c < channels - 3; c++) {
  608.      *out++ = *in++;
  609.     }
  610.    }
  611.   }
  612.  }
  613.  
  614.  return 0;
  615. }
  616.  
  617.  
  618. } /* namespace cv */

参考

http://iyenn.com/rec/1661922.html

下载

源码下载

天天代码码天天
微信公众号
.NET 人工智能实践
注：本文转载自blog.csdn.net的天天代码码天天的文章"https://lw112190.blog.csdn.net/article/details/141137754"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！