OpenCV学习Histogram&equalizeHist&Lomography effect&Cartoonize effect实现

本小实验完成如下五个功能：

1：使用trackbar实现button功能（OpenCV不自带button，不用QT我只能用trackerbar来实现可视化操作了）；

2：计算并绘制直方图；

3：Histogram equalization；

4：实现lomography效果；

5：实现cartoonize效果。

        3中为了色调均衡化一幅彩色图像，我们可以对图像的HSV 或 YCrCb格式分别对各个通道进行均衡化，这里我们对图像YCrCb格式的Y通道进行均衡化。先split分离出YCrCb格式图像的不同通道的矩阵，再对Y通道进行equalizeHist均衡化，然后merge合并通道，最后把图像转换为RGB图像。

        4中实现实现lomography效果分两步进行。先对red通道进行LUT操作实现曲线变换，变换公式如下：



该公式实现的效果是增强图像的对比度



接下来对图像增加暗晕（dark halo），最后multiply操作实现效果。
        5中实现cartoonize效果，第一步检测出图像的边缘，当然先要进行降噪处理，检测到边缘后进行膨胀操作连接断续的边缘。最后实现目标效果边缘图像与彩色图像进行multiply操作实现效果。

        具体见代码。
// OpenCV includes
#include "opencv2/core/utility.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"

using namespace cv;
using namespace std;

Mat img;

void showHisto(int state, void* userData);
void equalize(int state, void* userData);
void lomo(int state, void* userData);
void cartoon(int state, void* userData);

// OpenCV command line parser functions
// Keys accecpted by command line parser
const char* keys =
{
"{help h usage ? | | print this message}"
"{@image | | Image to process}"
};

char* trackbar_name = "mode 1-4";
char* window_name = "Mode Table";
int modeL = 0;
int modeH = 4;

void switchMode(int pos, void*) {
if (pos == 1)
{
showHisto(0, 0);
}
if (pos == 2)
{
equalize(0, 0);
}
if (pos == 3)
{
lomo(0, 0);
}
if (pos == 4)
{
cartoon(0, 0);
}
}

int main(int argc, const char** argv)
{
/*
CommandLineParser parser(argc, argv, keys);
parser.about("Chapter 4. PhotoTool v1.0.0");
//If requires help show
if (parser.has("help"))
{
parser.printMessage();
return 0;
}

String imgFile = parser.get<String>(0);
// Check if params are correctly parsed in his variables
if (!parser.check())
{
parser.printErrors();
return 0;
}
*/

// Load image to process
img = imread("E:/VS2013/face/xuelian/jpg/1.jpg");
if (!img.data)
{
return -1;
}
// Create window
namedWindow(window_name);

// Create UI buttons
/*
createButton("Show histogram", showHistoCallback, NULL, QT_PUSH_BUTTON, 0);
createButton("Equalize histogram", equalizeCallback, NULL, QT_PUSH_BUTTON, 0);
createButton("Lomography effect", lomoCallback, NULL, QT_PUSH_BUTTON, 0);
createButton("Cartonize effect", cartoonCallback, NULL, QT_PUSH_BUTTON, 0);
*/

createTrackbar(trackbar_name, window_name, &modeL, modeH, switchMode);//使用trackbar实现button功能

// Show image
//imshow("Input", img);
waitKey(0);
return 0;
}

void showHisto(int state, void* userData)
{
// 分割成3个单通道图像 ( B, G 和 R )
vector<Mat> bgr;
split(img, bgr);

//设定bin数目，划分的子区间个数
int numbins = 256;

//设定像素值范围 (前面已经提到,在 0 到 255之间 )
float range[] = { 0, 255 };
const float* histRange = { range };

//创建储存直方图的矩阵
Mat b_hist, g_hist, r_hist;

// 计算直方图
/*
bgr[i]:输入数组(或数组集)
1: 输入数组的个数 (这里我们使用了一个单通道图像，我们也可以输入数组集 )
0: 需要统计的通道 (dim)索引 ，这里我们只是统计了灰度 (且每个数组都是单通道)所以只要写 0 就行了
Mat(): 掩码( 0 表示忽略该像素)， 如果未定义，则不使用掩码
b_hist: 储存直方图的矩阵
1: 直方图维数
numbins: 每个维度的bin数目
histRange: 每个维度的取值范围
*/
calcHist(&bgr[0], 1, 0, Mat(), b_hist, 1, &numbins, &histRange);
calcHist(&bgr[1], 1, 0, Mat(), g_hist, 1, &numbins, &histRange);
calcHist(&bgr[2], 1, 0, Mat(), r_hist, 1, &numbins, &histRange);
// Draw the histogram
// We go to draw lines for each channel
int width = 512;
int height = 300;
int binStep = cvRound((float)width / (float)numbins);//一个double型的数进行四舍五入，并返回一个整型数

// Create image with gray base
Mat histImage(height, width, CV_8UC3, Scalar(20, 20, 20));

// Normalize the histograms to height of image
// 将直方图归一化到范围[0, histImage.rows]
/*
r_hist: 输入数组
r_hist: 归一化后的输出数组(支持原地计算)
0 及 histImage.rows: 这里，它们是归一化 r_hist 之后的取值极限
NORM_MINMAX: 归一化方法 (例中指定的方法将数值缩放到以上指定范围)
*/
normalize(b_hist, b_hist, 0, height, NORM_MINMAX);
normalize(g_hist, g_hist, 0, height, NORM_MINMAX);
normalize(r_hist, r_hist, 0, height, NORM_MINMAX);

for (int i = 1; i< numbins; i++)
{
//line( Mat img, Point start, Point end )
line(histImage,
Point(binStep*(i - 1), height - cvRound(b_hist.at<float>(i - 1))),
Point(binStep*(i), height - cvRound(b_hist.at<float>(i))),
Scalar(255, 0, 0));
line(histImage,
Point(binStep*(i - 1), height - cvRound(g_hist.at<float>(i - 1))),
Point(binStep*(i), height - cvRound(g_hist.at<float>(i))),
Scalar(0, 255, 0));
line(histImage,
Point(binStep*(i - 1), height - cvRound(r_hist.at<float>(i - 1))),
Point(binStep*(i), height - cvRound(r_hist.at<float>(i))),
Scalar(0, 0, 255));
}
imshow("Histogram", histImage);
}

void equalize(int state, void* userData)
{
Mat result;
// Convert BGR image to YCbCr
Mat ycrcb;
cvtColor(img, ycrcb, COLOR_BGR2YCrCb);
// Split image into channels
vector<Mat> channels;
split(ycrcb, channels);
// Equalize the Y channel only
equalizeHist(channels[0], channels[0]);
// Merge the result channels
merge(channels, ycrcb);
// Convert color ycrcb to BGR
cvtColor(ycrcb, result, COLOR_YCrCb2BGR);
// Show image
imshow("Equalized", result);
}

void lomo(int state, void* userData)
{
Mat result;
const double exponential_e = std::exp(1.0);
// Create Lookup table for color curve effect
Mat lut(1, 256, CV_8UC1);//建立一个256个元素的映射表
for (int i = 0; i<256; i++)
{
float x = (float)i / 256.0;
lut.at<uchar>(i) = cvRound(256 * (1 / (1 + pow(exponential_e, -((x - 0.5) / 0.1)))));//pow(InputArray src, double p, OutputArray dst)
}
// Split the image channels and apply curve transform only to red channel
vector<Mat> bgr;
split(img, bgr);
LUT(bgr[2], lut, bgr[2]);
// merge result
merge(bgr, result);
// Create image for halo dark
Mat halo(img.rows, img.cols, CV_32FC3, Scalar(0.3, 0.3, 0.3));
// Create circle
circle(halo, Point(img.cols / 2, img.rows / 2), img.cols / 3, Scalar(1, 1, 1), -1);
blur(halo, halo, Size(img.cols / 3, img.cols / 3));
// Convert the result to float to allow multiply by 1 factor
Mat resultf;
result.convertTo(resultf, CV_32FC3);
// Multiply our result with halo
multiply(resultf, halo, resultf);
// convert to 8 bits
resultf.convertTo(result, CV_8UC3);
// show result
imshow("Lomo Effect", result);
}

void cartoon(int state, void* userData)
{
/** EDGES **/
// Apply median filter to remove possible noise
Mat imgMedian;
medianBlur(img, imgMedian, 7);
// Detect edges with canny
Mat imgCanny;
Canny(imgMedian, imgCanny, 50, 150);
// Dilate the edges使断续的边缘连接
Mat kernel = getStructuringElement(MORPH_RECT, Size(2, 2));
dilate(imgCanny, imgCanny, kernel);
// Scale edges values to 1 and invert values
imgCanny = imgCanny / 255;
imgCanny = 1 - imgCanny;
// Use float values to allow multiply between 0 and 1
Mat imgCannyf;
imgCanny.convertTo(imgCannyf, CV_32FC3);
// Blur the edgest to do smooth effect平滑边缘
blur(imgCannyf, imgCannyf, Size(5, 5));
/** COLOR **/
// Apply bilateral filter to homogenizes color
Mat imgBF;
bilateralFilter(img, imgBF, 9, 150.0, 150.0);
// truncate colors
Mat result = imgBF / 25;
result = result * 25;
/** MERGES COLOR + EDGES **/
// Create a 3 channles for edges
Mat imgCanny3c;
Mat cannyChannels[] = { imgCannyf, imgCannyf, imgCannyf };
merge(cannyChannels, 3, imgCanny3c);
// Convert color result to float
Mat resultf;
result.convertTo(resultf, CV_32FC3);
// Multiply color and edges matrices
multiply(resultf, imgCanny3c, resultf);
// convert to 8 bits color
resultf.convertTo(result, CV_8UC3);
// Show image
imshow("cartoon Effect", result);
}