opencv--python(四)haar,直方图+反向投影，meanshift和Camshift追踪算法

1. haar人脸检测器

OpenCV 已经包含了很多已经训练好的分类器，其中包括：面部，眼睛，微笑等。我们只需加载需要的 XML 分类器。然后以灰度格式加载输入图像或者是视频。如果检测到面部，它会返回面部所在的矩形区域 Rect（x,y,w,h）

import numpy as np
import cv2

#加载需要的xml分类器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')

#以灰度格式加载输入图像或者是视频。
img = cv2.imread('sachin.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

#应用：如果检测到面部，它会返回面部所在的矩形 区域 Rect（x,y,w,h）。之后我们可以创建一个 ROI 在其中进行眼部检测。
for (x,y,w,h) in faces:
    img = cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = img[y:y+h, x:x+w]
    eyes = eye_cascade.detectMultiScale(roi_gray)
    for (ex,ey,ew,eh) in eyes:
        cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)

cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

效果：

2.直方图+反射变换

import cv2
import numpy as np
roi = cv2.imread('roi.jpg')
hsv = cv2.cvtColor(roi,cv2.COLOR_BGR2HSV)

target = cv2.imread('tar.jpg')
hsvt = cv2.cvtColor(target,cv2.COLOR_BGR2HSV) #转HSV

roihist = cv2.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )   #计算直方图
cv2.normalize(roihist,roihist,0,255,cv2.NORM_MINMAX)   #归一化
dst = cv2.calcBackProject([hsvt],[0,1],roihist,[0,180,0,256],1)   #反向投影

#卷积把分散的点连在一起
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
dst=cv2.filter2D(dst,-1,disc)

ret,thresh = cv2.threshold(dst,50,255,0) # 别忘了是三通道图像，因此这里使用 merge 变成 3
thresh = cv2.merge((thresh,thresh,thresh))
res = cv2.bitwise_and(target,thresh) # 按位操作

res = np.hstack((target,thresh,res))
cv2.imwrite('res.jpg',res)       # 显示图像 cv2.imshow('1',res)
cv2.waitKey(0)

转HSV（色调，饱和度，明度）：用颜色直方图，因为一个物体的颜色要比它的灰度能更好的被用来进行图像分割与对象识别。
直方图：通过直方图你可以对整幅图像的灰度分布有一个整体了解。直方图的 x 轴是灰度值（0 到 255），y 轴是图片中具有同一个灰度值点的数目。
反向投影：它可以用来做图像分割，或者在图像中找寻我们感兴趣的部分。简单来说，它会输出与输入图像（待搜索）同样大小的图像，其中的每一个像素值代表了概率信息。就是说，输出图像中像素值越高（越白）的点就越可能是我们要搜索的目标 。
归一化: 映射到结果图像中的最小值，最大值，归一化类型 #cv2.NORM_MINMAX 对数组的所有值进行转化，使它们线性映射到最小值和最大值之间归一化之后的直方图便于显示，归一化之后就成了 0 到 255 之间的数了。

3. meanshift和Camshift

1). Meanshift
算法的基本原理: 假设我们有一堆点（比如直方图反向投影得到的点），和一个小的圆形窗口，我们要完成的任务就是将这个窗口移动到最大灰度密度处（或者是点最多的地方）。如下图所示：

初始窗口是蓝色的“C1”，它的圆心为蓝色方框“C1_o”，而窗口中所有点质 心却是“C1_r”(小的蓝色圆圈)，很明显圆心和点的质心没有重合。所以移动圆 心 C1_o 到质心 C1_r，这样我们就得到了一个新的窗口。这时又可以找到新 窗口内所有点的质心，大多数情况下还是不重合的，所以重复上面的操作：将新窗口的中心移动到新的质心。就这样不停的迭代操作直到窗口的中心和其所包含点的质心重合为止（或者有一点小误差）。

2).Camshift
原理：meanshift窗口的大小是固 定的，而汽车由远及近（在视觉上）是一个逐渐变大的过程，固定的窗口是不 合适的。所以我们需要根据目标的大小和角度来对窗口的大小和角度进行修订，所以有了Camshift.

代码实现：

import numpy as np
import cv2

cap = cv2.VideoCapture('slow.flv')

ret,frame = cap.read()

r,h,c,w = 250,90,400,125
track_window = (c,r,w,h)

roi = frame[r:r+h, c:c+w]
hsv_roi = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))  #设阈值，去除背景部分，低于lower_red和高于upper_red的部分分别变成0，lower_red～upper_red之间的值变成255
roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180])   #直方图
cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX)    #归一化

term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
while(1):
    ret ,frame = cap.read()
    if ret == True:
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1)   #在原图HSV上做反向投影

        ret, track_window = cv2.CamShift(dst, track_window, term_crit)    #进行目标追踪
        
        #Draw it on image 
        pts = cv2.boxPoints(ret)
        pts = np.int0(pts)
        img2 = cv2.polylines(frame,[pts],True, 255,2)
        cv2.imshow('img2',img2)

        k = cv2.waitKey(60) & 0xff
        if k == 27:
            break
        else:
            cv2.imwrite(chr(k)+".jpg",img2)
    else:
        break

cv2.destroyAllWindows()
cap.release()

#######################################################################################

#详解版：
import cv2
import numpy as np

cap = cv2.VideoCapture(0)

# ret判断是否读到图片
# frame读取到的当前帧的矩阵
# 返回的是元组类型，所以也可以加括号
ret, frame = cap.read()
# print(type(ret), ret)
# print(type(frame), frame)


# 设置跟踪框参数
r,h,c,w = 250,90,400,125  # simply hardcoded the values
track_window = (c,r,w,h)

# 从当前帧中框出一个小框
roi = frame[r:r+h, c:c+w]
# RGB转为HSV更好处理
hsv_roi =  cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

# inRange函数设置亮度阈值
# 去除低亮度的像素点的影响
# eg. mask = cv2.inRange(hsv, lower_red, upper_red)

# 将低于和高于阈值的值设为0
mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))

# 然后得到框中图像的直方图
# cv2.calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate ]])
# mask 即上文的阈值设置
# histSize表示这个直方图分成多少份（即多少个直方柱）
# range是表示直方图能表示像素值的范围
# 返回直方图
roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180])

# 归一化函数cv2.normalize(src[, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]])
# 返回dst类型
# 归一化就是要把需要处理的数据经过处理后（通过某种算法）限制在你需要的一定范围内
# src  - 输入数组
# dst  - 与src大小相同的输出数组
# alpha  - 范围值，   以便在范围归一化的情况下归一化到较低范围边界
# beta  - 范围归一化时的上限范围; 它不用于标准规范化
# normType  - 规范化类型 这里的NORM_MINMAX是数组的数值被平移或缩放到一个指定的范围，线性归一化。
# dtype  - 当为负数时，输出数组与src的类型相同；否则，它具有与src相同的通道数；深度=CV_MAT_DEPTH（dtype）
# mask  - 可选的操作掩码。
cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX)

# 设置迭代的终止标准，最多十次迭代
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )

while(1):
    ret ,frame = cap.read()

    if ret == True:
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

        # 反向投影函数（特征提取函数）
        # 反向投影是一种记录给定图像中的像素点如何适应直方图模型像素分布的方式
        # 反向投影就是首先计算某一特征的直方图模型，然后使用模型去寻找图像中存在的特征
        # cv2.calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate]])

        # images:待处理的图像，图像格式为uint8或float32
        # channels:对应图像需要统计的通道，若是灰度图则为0，彩色图像B、G、R对应0、1、2
        # mask:掩膜图像。如果统计整幅图像就设置为None，否则这里传入设计的掩膜图像。
        # histSize表示这个直方图分成多少份（即多少个直方柱）
        # ranges:像素量化范围，通常为0 - 255。
        dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1)

        # RotatedRect CamShift(InputArray probImage, Rect&window, TermCriteria criteria)。
        # probImage为输入图像直方图的反向投影图，
        # window为要跟踪目标的初始位置矩形框，
        # criteria为算法结束条件。
        # 函数返回一个有方向角度的矩阵。
        #
        ret, track_window = cv2.CamShift(dst, track_window, term_crit)

        # Draw it on image
        pts = cv2.boxPoints(ret)

        # 类型转换int0()用于索引的整数(same as C ssize_t; normally either int32 or int64)
        pts = np.int0(pts)

        # 非填充多边形：polylines()
        # cv2.polylines(img, pts, isClosed, color[, thickness[, lineType[, shift]]])
        # img – 要画的图片
        # pts – 多边形的顶点
        # isClosed – 是否闭合线段
        # color – 颜色
        img2 = cv2.polylines(frame,[pts],True, 255,2)
        
        cv2.imshow('img2',img2)

        # 停止追踪按钮
        k = cv2.waitKey(60) & 0xff
        if k == 27:
            break
        else:
            cv2.imwrite(chr(k)+".jpg",img2)

    else:
        break

cv2.destroyAllWindows()
cap.release()