写在前面

HSV是一种将RGB色彩空间中的点在倒圆锥体中的表示方法。HSV即色相(Hue)、饱和度(Saturation)、明度(Value)，又称HSB(B即Brightness)。色相是色彩的基本属性，就是平常说的颜色的名称，如红色、黄色等。饱和度（S）是指色彩的纯度，越高色彩越纯，低则逐渐变灰，取0-100%的数值。明度（V），取0-max(计算机中HSV取值范围和存储的长度有关)。HSV颜色空间可以用一个圆锥空间模型来描述。圆锥的顶点处，V=0，H和S无定义，代表黑色。圆锥的顶面中心处V=max，S=0，H无定义，代表白色。

RGB颜色空间中，三种颜色分量的取值与所生成的颜色之间的联系并不直观。而HSV颜色空间，更类似于人类感觉颜色的方式，封装了关于颜色的信息：“这是什么颜色？深浅如何？明暗如何？”

HSV模型：

这个模型就是按色彩、深浅、明暗来描述的。

H是色彩；

S是深浅， S = 0时，只有灰度；

V是明暗，表示色彩的明亮程度，但与光强无直接联系。

应用：同HSI一样，可以用于偏光矫正、去除阴影、图像分割等。

RGB与HSV转换

1、RGB2HSV

或

2、HSV2RGB

实现

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
using namespace cv;


Mat RGB2HSV(Mat src) {
    int row = src.rows;
    int col = src.cols;
    Mat dst(row, col, CV_32FC3);
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            float b = src.at<Vec3b>(i, j)[0] / 255.0;
            float g = src.at<Vec3b>(i, j)[1] / 255.0;
            float r = src.at<Vec3b>(i, j)[2] / 255.0;
            float minn = min(r, min(g, b));
            float maxx = max(r, max(g, b));
            dst.at<Vec3f>(i, j)[2] = maxx; //V
            float delta = maxx - minn;
            float h, s;
            if (maxx != 0) {
                s = delta / maxx;
            }
            else {
                s = 0;
            }
            if (r == maxx) {
                h = (g - b) / delta;
            }
            else if (g == maxx) {
                h = 2 + (b - r) / delta;
            }
            else if (b==maxx) {
                h = 4 + (r - g) / delta;
            }
            else{
                h = 0;
            }
            h *= 60;
            if (h < 0)
                h +=  360;
            dst.at<Vec3f>(i, j)[0] = h;
            dst.at<Vec3f>(i, j)[1] = s;
        }
    }

    return dst;
}

Mat HSV2RGB(Mat src) {
    int row = src.rows;
    int col = src.cols;
    Mat dst(row, col, CV_8UC3);
    float r, g, b, h, s, v;
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            h = src.at<Vec3f>(i, j)[0];
            s = src.at<Vec3f>(i, j)[1];
            v = src.at<Vec3f>(i, j)[2];
            if (s == 0) {
                r = g = b = v;
            }
            else {
                h /= 60;
                int offset = floor(h);
                float f = h - offset;
                float p = v * (1 - s);
                float q = v * (1 - s * f);
                float t = v * (1 - s * (1 - f));
                switch (offset)
                {
                case 0: r = v; g = t; b = p; break;
                case 1: r = q; g = v; b = p; break;
                case 2: r = p; g = v; b = t; break;
                case 3: r = p; g = q; b = v; break;
                case 4: r = t; g = p; b = v; break;
                case 5: r = v; g = p; b = q; break;
                default:
                    break;
                }
            }
            dst.at<Vec3b>(i, j)[0] = int(b * 255);
            dst.at<Vec3b>(i, j)[1] = int(g * 255);
            dst.at<Vec3b>(i, j)[2] = int(r * 255);
        }
    }
    return dst;
}




int main(){
    cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\lena.JPG");

    if (src.empty()){
        return -1;
    }
    cv::Mat dst, dst1, dst2;

    opencv自带/
    cv::cvtColor(src, dst1, CV_RGB2HSV); //RGB2HSV

    //RGB2HSV//
    dst = RGB2HSV(src); //RGB2HSV
    dst2 = HSV2RGB(dst); //HSV2BGR

    cv::namedWindow("src", CV_WINDOW_NORMAL);
    imshow("src", src);
    cv::namedWindow("My_RGB2HSV", CV_WINDOW_NORMAL);
    imshow("My_RGB2HSV", dst);
    cv::namedWindow("My_HSV2RGB", CV_WINDOW_NORMAL);
    imshow("My_HSV2RGB", dst2);
    cv::namedWindow("Opencv_RGB2HSV", CV_WINDOW_NORMAL);
    imshow("Opencv_RGB2HSV", dst1);
    cv::waitKey(0);
    return 0;

}

效果

参考：

https://blog.csdn.net/viewcode/article/details/8203728

https://blog.csdn.net/just_sort/article/details/87102898

https://blog.csdn.net/jiangxinyu/article/details/8000999