C++ 彩色图像(RGB)三通道直方图计算和绘制，图像逆时针旋转90° 实现代码

#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 0;
}

void calImgHistPro(vector<Mat> imgrgb,vector<vector<int>>& histData)
{
    vector<Mat> imgrgbSrc = imgrgb;
    int width = imgrgb[0].cols;
    int height = imgrgb[0].rows;
    for (int n = 0; n < imgrgb.size(); n++)
    {
        Mat imgSrc = imgrgbSrc[n].clone();        
        int img_sum = -1;
        vector<int> p(256);
        for (int m = 0; m <p.size() ; m++)
        {
            p[m] = 0;
        }
        for (int i = 0; i < height; i++)
        {
            uchar* ptr = imgSrc.ptr<uchar>(i);
            for (int j = 0; 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 = 0; m < 256; m++)
        {
            p[m] = p[m]*255 / img_sum;
        }
        histData.push_back(p);
    }
}

void showImgHistPro(vector<vector<int>>& histD)
{
    vector<vector<int>> histSrc=histD;
    int cols = histD[0].size();
    int rows = -1;
    Mat histRGB(cols , cols * 3, CV_8UC1, Scalar(0));
    for (int n = 0; n < histD.size(); n++)
    {
        vector<int> hist = histD[n];            
        Mat histImg(cols, cols, CV_8UC1, Scalar(0));
        for (int i = 0; i < cols; i++)
        {
            uchar* ptr = histImg.ptr(i);        
            for (int j = 0; j < hist[i]; j++)
            {                
                ptr[j] = 255;
            }        
        }    
        /*旋转90°*/
        Mat histImg1(cols, cols, CV_8UC1, Scalar(0));
        for (int l = 0; l < cols; l++)
        {            
            for (int k = 0; k < cols; k++)
            {
                histImg1.at<uchar>(l, k) = histImg.at<uchar>(k, cols-l-1);
            }
        }        
        histImg1.copyTo(histRGB(Rect(cols*n,0, cols, cols)));
    }
    imshow("Img_R_G_B", histRGB);
    waitKey(0);
}

void rotateImgPro(Mat& img,float angle)
{
    Mat retMat(img.cols, img.rows, CV_8UC1, Scalar(0));
    float anglePI = (float)(angle*CV_PI / 180);
    int xSm, ySm;
    for (int i = 0; i < retMat.rows; i++)
    {
        for (int j = 0; j < retMat.cols; j++)
        {
            xSm = (int)((i - retMat.rows / 2)*cos(anglePI) - 
                (j - retMat.cols / 2)*sin(anglePI) + 0.5);
            ySm = (int)((i - retMat.rows / 2)*sin(anglePI) + 
                (j - retMat.cols / 2)*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 = 0; 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 = 0; j < height; j++)
        {
            imgRPtr[j] = imgSPtr[0];
            imgGPtr[j] = imgSPtr[1];
            imgBPtr[j] = imgSPtr[2];
            imgSPtr += 3;            
        }
    }
    imgRGB.push_back(imgR);
    imgRGB.push_back(imgG);
    imgRGB.push_back(imgB);
}