#include "iostream"

 #include "opencv2/opencv.hpp"

 #include "vector"

 using namespace std;

 using namespace cv;

 /*计算真彩色图像的直方图*/

 void splitRgbImgPro(const Mat img, vector<Mat>& imgRGB);

 void calImgHistPro(vector<Mat> imgrgb, vector<vector<int>>& histData);

 void showImgHistPro(vector<vector<int>>& histD);

 void rotateImgPro(Mat& img, float angle);

 int main()

 {

     Mat imgSrc = imread("E:\\VideoPlateRecog\\ETC\\1008\\SRC\\144.bmp");

     /*色彩空间分离*/

     vector<Mat> imgRGB;

     splitRgbImgPro(imgSrc, imgRGB);

     /*计算三通道直方图*/

     vector<vector<int>> histData;

     calImgHistPro(imgRGB, histData);

     /*绘制三通道直方图*/

     showImgHistPro(histData);

     system("pause");

     return ;

 }

 void calImgHistPro(vector<Mat> imgrgb,vector<vector<int>>& histData)

 {

     vector<Mat> imgrgbSrc = imgrgb;

     int width = imgrgb[].cols;

     int height = imgrgb[].rows;

     for (int n = ; n < imgrgb.size(); n++)

     {

         Mat imgSrc = imgrgbSrc[n].clone();

         int img_sum = -;

         vector<int> p();

         for (int m = ; m <p.size() ; m++)

         {

             p[m] = ;

         }

         for (int i = ; i < height; i++)

         {

             uchar* ptr = imgSrc.ptr<uchar>(i);

             for (int j = ; j < width; j++)

             {

                 int k = ptr[j];

                 p[k]++;

             }

         }

         /*find max element of vector*/

         for (auto it = p.begin(); it != p.end(); it++)

         {

             if (*it > img_sum)

             {

                 img_sum = *it;

             }

         }

         for (int m = ; m < ; m++)

         {

             p[m] = p[m]* / img_sum;

         }

         histData.push_back(p);

     }

 }

 void showImgHistPro(vector<vector<int>>& histD)

 {

     vector<vector<int>> histSrc=histD;

     int cols = histD[].size();

     int rows = -;

     Mat histRGB(cols , cols * , CV_8UC1, Scalar());

     for (int n = ; n < histD.size(); n++)

     {

         vector<int> hist = histD[n];

         Mat histImg(cols, cols, CV_8UC1, Scalar());

         for (int i = ; i < cols; i++)

         {

             uchar* ptr = histImg.ptr(i);

             for (int j = ; j < hist[i]; j++)

             {

                 ptr[j] = ;

             }

         }

         /*旋转90°*/

         Mat histImg1(cols, cols, CV_8UC1, Scalar());

         for (int l = ; l < cols; l++)

         {

             for (int k = ; k < cols; k++)

             {

                 histImg1.at<uchar>(l, k) = histImg.at<uchar>(k, cols-l-);

             }

         }

         histImg1.copyTo(histRGB(Rect(cols*n,, cols, cols)));

     }

     imshow("Img_R_G_B", histRGB);

     waitKey();

 }

 void rotateImgPro(Mat& img,float angle)

 {

     Mat retMat(img.cols, img.rows, CV_8UC1, Scalar());

     float anglePI = (float)(angle*CV_PI / );

     int xSm, ySm;

     for (int i = ; i < retMat.rows; i++)

     {

         for (int j = ; j < retMat.cols; j++)

         {

             xSm = (int)((i - retMat.rows / )*cos(anglePI) -

                 (j - retMat.cols / )*sin(anglePI) + 0.5);

             ySm = (int)((i - retMat.rows / )*sin(anglePI) +

                 (j - retMat.cols / )*cos(anglePI) + 0.5);

                 retMat.at<uchar>(i, j) = img.at<uchar>(xSm, ySm);    

         }

     }

 }

 void splitRgbImgPro(const Mat img, vector<Mat>& imgRGB)

 {

     Mat imgSrc = img.clone();

     int width = imgSrc.rows;

     int height = imgSrc.cols;

     Mat imgR(width, height, CV_8UC1);

     Mat imgG(width, height, CV_8UC1);

     Mat imgB(width, height, CV_8UC1);

     for (int i = ; i < width; i++)

     {

         Vec3b* imgPtr = imgSrc.ptr<Vec3b>(i);

         uchar* imgSPtr = imgSrc.ptr<uchar>(i);

         uchar* imgRPtr = imgR.ptr<uchar>(i);

         uchar* imgGPtr = imgG.ptr<uchar>(i);

         uchar* imgBPtr = imgB.ptr<uchar>(i);

         for (int j = ; j < height; j++)

         {

             imgRPtr[j] = imgSPtr[];

             imgGPtr[j] = imgSPtr[];

             imgBPtr[j] = imgSPtr[];

             imgSPtr += ;

         }

     }

     imgRGB.push_back(imgR);

     imgRGB.push_back(imgG);

     imgRGB.push_back(imgB);

 }