直方图反向投影

视频讲解如下：

在本章节中给大家演示反向投影，当前代码同样是在毛星云的代码基础上进行扩展优化的。

当前系列所有demo下载地址：

https://github.com/GaoRenBao/OpenCv4-Demo

不同编程语言对应的OpenCv版本以及开发环境信息如下： 

首先呢，我们需要准备一张测试图片。（不想下载工程的童鞋，可直接复制下面的图片和代码）

三个版本的运行效果其实都是一样的，我这里就单独拿C#版本的来做演示，运行效果如下：

C#版本代码如下：

C#版本需要安装“OpenCvSharp4”、“OpenCvSharp4.runtime.win”两个库才行。不然会报错。

如果需要使用“ BitmapConverter.ToBitmap”操作，则需要追加安装“OpenCvSharp4.Extensions”库。

using OpenCvSharp;
using System;

namespace demo
{
    internal class Program
    {
        static string WINDOW_NAME1 = "【原始图】";
        static Mat g_srcImage = new Mat();
        static Mat g_hsvImage = new Mat();
        static Mat g_hueImage = new Mat();
        static int g_bins = 30;//直方图组距

        static void Main(string[] args)
        {
            //【1】读取源图像，并转换到 HSV 空间
            g_srcImage = Cv2.ImRead("../../../images/hand.jpg");
            if (g_srcImage.Empty())
            {
                Console.WriteLine("读取图片错误，请确定目录下是否有imread函数指定图片存在~！");
                return;
            }

            //【2】得到原图的灰度图像并进行平滑
            g_hsvImage = new Mat();
            Cv2.CvtColor(g_srcImage, g_hsvImage, ColorConversionCodes.BGR2HSV);

            //【2】分离 Hue 色调通道
            g_hueImage = Mat.Zeros(g_hsvImage.Size(), g_hsvImage.Type());
            int[] ch = { 0, 0 };
            Mat[] input = { g_hsvImage };
            Mat[] output = { g_hueImage };
            Cv2.MixChannels(input, output, ch);

            //【3】创建 Trackbar 来输入bin的数目
            // opencv3：WindowMode.AutoSize
            // opencv4：WindowFlags.AutoSize
            Cv2.NamedWindow(WINDOW_NAME1, WindowFlags.AutoSize);
            Cv2.CreateTrackbar("色调组距:", WINDOW_NAME1, ref g_bins, 180, on_BinChange);
            on_BinChange(0, IntPtr.Zero);
            Cv2.WaitKey(0);
        }

        // opencv3：on_BinChange(int pos, object userData)
        // opencv4：on_BinChange(int pos, IntPtr userData)
        private static void on_BinChange(int pos, IntPtr userData)
        {
            int[] channels = { 0 };
            Mat hist = new Mat();
            int[] histSize = { Math.Max(g_bins, 2) };
            Rangef hue_range = new Rangef(0, 180);
            Rangef[] ranges = { hue_range };

            //【2】计算直方图并归一化
            Cv2.CalcHist(new Mat[] { g_hueImage },//输入的数组
                channels, // 通道索引
                null,     // 不使用掩膜
                hist,  // 输出的目标直方图
                1,        // 需要计算的直方图的维度为2
                histSize,     // 存放每个维度的直方图尺寸的数组
                ranges,   // 每一维数值的取值范围数组
                true,     // 指示直方图是否均匀的标识符，true表示均匀的直方图
                false);   // 累计标识符，false表示直方图在配置阶段会被清零

            Cv2.Normalize(hist, hist, 0, 255, NormTypes.MinMax, -1);

            //【3】计算反向投影
            Mat backproj = new Mat();
            Cv2.CalcBackProject(new Mat[] { g_hueImage }, channels, hist, backproj, ranges, true);

            //【4】显示反向投影
            Cv2.ImShow("反向投影图", backproj);

            //【5】绘制直方图的参数准备
            int w = 400; int h = 400;
            int bin_w = (int)Math.Round((double)w / histSize[0]);

            Mat histImg = new Mat(new Size(w, h), MatType.CV_8UC3);
            histImg.SetIdentity(new Scalar(0));

            //【6】绘制直方图
            for (int i = 0; i < g_bins; i++)
            {
                Rect rect = new Rect()
                {
                    X = Math.Min(i * bin_w, (i + 1) * bin_w),
                    Y = (int)Math.Min(h, h - Math.Round(hist.At<float>(i) * h / 255.0)),
                    Height = Math.Abs((int)Math.Round(hist.At<float>(i) * h / 255.0)),
                    Width = bin_w
                };
                Cv2.Rectangle(histImg, rect, new Scalar(100, 123, 255), -1);
            }

            //【7】显示直方图窗口
            Cv2.ImShow("直方图", histImg);
        }
    }
}

C++版本代码如下：

#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
using namespace cv;

// 为窗口标题定义的宏 
#define WINDOW_NAME1 "反向投影图"        

Mat g_srcImage; Mat g_hsvImage; Mat g_hueImage;
int g_bins = 30;//直方图组距

void on_BinChange(int, void*)
{
	//【1】参数准备
	MatND hist;
	int histSize = MAX(g_bins, 2);
	float hue_range[] = { 0, 180 };
	const float* ranges = { hue_range };

	//【2】计算直方图并归一化
	calcHist(&g_hueImage, 1, 0, Mat(), hist, 1, &histSize, &ranges, true, false);
	normalize(hist, hist, 0, 255, NORM_MINMAX, -1, Mat());

	//【3】计算反向投影
	MatND backproj;
	calcBackProject(&g_hueImage, 1, 0, hist, backproj, &ranges, 1, true);

	//【4】显示反向投影
	imshow(WINDOW_NAME1, backproj);

	//【5】绘制直方图的参数准备
	int w = 400; int h = 400;
	int bin_w = cvRound((double)w / histSize);
	Mat histImg = Mat::zeros(w, h, CV_8UC3);

	//【6】绘制直方图
	for (int i = 0; i < g_bins; i++)
	{
		rectangle(histImg, Point(i * bin_w, h), Point((i + 1) * bin_w, h - cvRound(hist.at<float>(i) * h / 255.0)), Scalar(100, 123, 255), -1);
	}

	//【7】显示直方图窗口
	imshow("直方图", histImg);
}

int main()
{
	//【1】读取源图像，并转换到 HSV 空间
	g_srcImage = imread("../images/hand.jpg", 1);
	if (!g_srcImage.data) { printf("读取图片错误，请确定目录下是否有imread函数指定图片存在~！ \n"); return false; }

	cvtColor(g_srcImage, g_hsvImage,COLOR_BGR2HSV);

	//【2】分离 Hue 色调通道
	g_hueImage.create(g_hsvImage.size(), g_hsvImage.depth());
	int ch[] = { 0, 0 };
	mixChannels(&g_hsvImage, 1, &g_hueImage, 1, ch, 1);

	//【3】创建 Trackbar 来输入bin的数目
	namedWindow(WINDOW_NAME1, WINDOW_AUTOSIZE);
	createTrackbar("色调组距 ", WINDOW_NAME1, &g_bins, 180, on_BinChange);
	on_BinChange(0, 0);//进行一次初始化

	//【4】显示效果图
	imshow(WINDOW_NAME1, g_srcImage);

	// 等待用户按键
	waitKey(0);
	return 0;
}

Python版本代码如下：

import cv2
import numpy as np


def on_BinChange(x):
    global g_hueImage

    # 获取滑动条的值
    g_bins = cv2.getTrackbarPos('g_bins', 'backproj')

    # 计算直方图并归一化
    histSize = [max(g_bins, 2)]
    hist = cv2.calcHist([g_hueImage], [0], None, histSize, [0, 180])
    cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)

    # 计算反向投影
    backproj = cv2.calcBackProject([g_hueImage], [0], hist, [0, 180], 1)

    # 显示反向投影
    cv2.imshow("backproj", backproj)

    # 绘制直方图的参数准备
    w = 400
    h = 400
    bin_w = int(w / histSize[0])
    histImg = np.zeros((w, h, 3), np.uint8)

    # 绘制直方图
    for i in range(g_bins):
        cv2.rectangle(histImg, (i * bin_w, h), (int((i + 1) * bin_w), int(h - hist[i][0] * h / 255.0)),
                      (100, 123, 255), -1)

    # 显示直方图窗口
    cv2.imshow("histImg", histImg)


# 读取源图像，并转换到 HSV 空间
g_srcImage = cv2.imread("../images/hand.jpg")
g_hsvImage = cv2.cvtColor(g_srcImage, cv2.COLOR_BGR2HSV)

# 【2】分离 Hue 色调通道
g_hueImage = np.zeros((g_hsvImage.shape[0], g_hsvImage.shape[1], 3), np.uint8)
ch = [0, 0]
cv2.mixChannels([g_hsvImage], [g_hueImage], ch)

# 创建 Trackbar 来输入bin的数目
cv2.namedWindow('backproj')
cv2.createTrackbar('g_bins', 'backproj', 0, 180, on_BinChange)
cv2.setTrackbarPos('g_bins', 'backproj', 30)

# 等待用户按键
cv2.waitKey(0)
cv2.destroyAllWindows()

在python版本中，可以利用matplotlib来显示我们的直方图数据，以下demo的详细说明，请参考pdf，pdf中并没用提供一个完整的demo，已代码为博主根据文档自行整理的。

参考来源：OpenCV-Python-Tutorial-中文版.pdf（P141 直方图反向投影）

在线预览

        直方图反向投影是由MichaelJ.Swain和Dana.H.Ballard在他们的文章”Indexingviacolorhistograms”中提出。

        那它到底是什么呢？它可以用来做图像分割，或者在图像中找寻我们感兴趣的部分。简单来说，它会输出与输入图像（待搜索）同样大小的图像，其中的每一个像素值代表了输入图像上对应点属于目标对象的概率。用更简单的话来解释，输出图像中像素值越高（越白）的点就越可能代表我们要搜索的目标（在输入图像所在的位置）。这是一个直观的解释。直方图投影经常与camshift算法等一起使用。

        我们应该怎样来实现这个算法呢？首先我们要为一张包含我们要查找自标的图像创建直方图（在我们的示例中，我们要查找的是草地，其他的都不要）。我们要查找的对象要尽量占满这张图像（换句话说，这张图像上最好是有且仅有我们要查找的对象）。最好使用颜色直方图，因为一个物体的颜色要比它的灰度能更好的被用来进行图像分割与对象识别。接着我们再把这个颜色直方图投影到输入图像中寻找我们的目标，也就是找到输入图像中的每一个像素点的像素值在直方图中对应的概率，这样我们就得到一个概率图像，最后设置适当的闹值对概率图像进行二值化，就这么简单。

演示之前我们需要做准备一张ROI图片：

执行效果如下：

import cv2
import numpy as np
from matplotlib import pyplot as plt

# Numpy 中的算法

# roi is the object or region of object we need to find
roi = cv2.imread('home5.jpg')
hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
# target is the image we search in
target = cv2.imread('home4.jpg')

hsvt = cv2.cvtColor(target, cv2.COLOR_BGR2HSV)
# Find the histograms using calcHist. Can be done with np.histogram2d also
M = cv2.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])
I = cv2.calcHist([hsvt], [0, 1], None, [180, 256], [0, 180, 0, 256])

h, s, v = cv2.split(hsvt)
R=M/I
B = R[h.ravel(), s.ravel()]
B = np.minimum(B, 1)
B = B.reshape(hsvt.shape[:2])

disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
B = cv2.filter2D(B, -1, disc)
B = np.uint8(B)
cv2.normalize(B, B, 0, 255, cv2.NORM_MINMAX)

ret,thresh = cv2.threshold(B,50,255,0)
cv2.imwrite('calcHist_out.jpg', thresh)
cv2.waitKey(0)