目标检测 目标识别
HOG:特征描述符 按八个方向计算颜色梯度 一个单元16*16像素 一个块2*2单元 按块构成特征向量
图像金字塔:使用任意尺度缩小图像大小 使用高斯模糊平滑图像 图像比最小尺寸还大则重复操作
滑动窗口:解决定位问题 使用图像金字塔在不同尺度下重复扫描
非最大抑制:解决区域重叠问题
1.建立图像金字塔,采用滑动窗口搜素图像
2.收集所有超出阈值的含目标窗口,并得到最高响应的窗口W
3.消除所有与W有明显重叠的窗口
4.移动到下一个有最高相应的窗口,在当前尺度下重复上述过程
5.移动图像到金字塔的下一个尺度,重复上述过程
SVM:分类 确定窗口的置信度评分
BOG:词袋技术
1.取一个样本数据集
2.对数据集中的每幅图像提取描述符
3.将每个描述符都添加到BOW训练器中
4.将描述符聚类到k簇中
import cv2
import numpy as np
from os.path import join
datapath = "CarData/TrainImages/"
def path(cls,i):
return "%s/%s%d.pgm" % (datapath,cls,i+1)
pos, neg = "pos-", "neg-"
detect = cv2.xfeatures2d.SIFT_create()
extract = cv2.xfeatures2d.SIFT_create()#SIFT特征提取
flann_params = dict(algorithm = 1, trees = 5)
matcher = cv2.FlannBasedMatcher(flann_params, {})#FLANN特征匹配
bow_kmeans_trainer = cv2.BOWKMeansTrainer(40)#初始化BOW训练器 簇数40
extract_bow = cv2.BOWImgDescriptorExtractor(extract, matcher)#初始化BOW提取器
def extract_sift(fn):
im = cv2.imread(fn,0)################### 1.取一个样本数据集
return extract.compute(im, detect.detect(im))[1]# 2.对数据集中的每幅图像提取描述符
for i in range(8):#每个类8个正样本8个负样本
bow_kmeans_trainer.add(extract_sift(path(pos,i)))# 3.将每个描述符都添加到BOW训练器中
bow_kmeans_trainer.add(extract_sift(path(neg,i)))
vocabulary = bow_kmeans_trainer.cluster()####### 4.将描述符聚类到k簇中
extract_bow.setVocabulary( vocabulary )
def bow_features(fn):
im = cv2.imread(fn,0)
return extract_bow.compute(im, detect.detect(im))
traindata, trainlabels = [],[]#训练数据和标签
for i in range(20):
traindata.extend(bow_features(path(pos, i))); trainlabels.append(1)#基于BOW描述符提取器计算得到的描述符
traindata.extend(bow_features(path(neg, i))); trainlabels.append(-1)
svm = cv2.ml.SVM_create()#创建svm实例
svm.train(np.array(traindata), cv2.ml.ROW_SAMPLE, np.array(trainlabels))#训练SVM分类器
def predict(fn):
f = bow_features(fn); #基于BOW描述符提取器计算测试图片的描述符
p = svm.predict(f)
print fn, "\t", p[1][0][0]
return p
car, notcar = "../images/car.jpg", "../images/bb.jpg"
car_img = cv2.imread(car)
notcar_img = cv2.imread(notcar)
car_predict = predict(car)
not_car_predict = predict(notcar)
font = cv2.FONT_HERSHEY_SIMPLEX
if (car_predict[1][0][0] == 1.0):
cv2.putText(car_img,'Car Detected',(10,30), font, 1,(0,255,0),2,cv2.LINE_AA)#cv2.putText
if (not_car_predict[1][0][0] == -1.0):
cv2.putText(notcar_img,'Car Not Detected',(10,30), font, 1,(0,0, 255),2,cv2.LINE_AA)
cv2.imshow('BOW + SVM Success', car_img)
cv2.imshow('BOW + SVM Failure', notcar_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
滑动窗口 图像金字塔
|- car_sliding_windows.py
|- car_detector
|- __init__.py
|- detector.py
|- non_maximum.py
|- pyramid.py
|- sliding_window.py
car_sliding_windows.py
import cv2
import numpy as np
from car_detector.detector import car_detector, bow_features
from car_detector.pyramid import pyramid
from car_detector.non_maximum import non_max_suppression_fast as nms
from car_detector.sliding_window import sliding_window
import urllib
def in_range(number, test, thresh=0.2):
return abs(number - test) < thresh
test_image = "../images/cars.jpg"
img_path = "../images/test.jpg"
urllib.urlretrieve(test_image, img_path)
svm, extractor = car_detector()
detect = cv2.xfeatures2d.SIFT_create()
w, h = 100, 40
img = cv2.imread(img_path)
#img = cv2.imread(test_image)
rectangles = []
counter = 1
scaleFactor = 1.25
scale = 1
font = cv2.FONT_HERSHEY_PLAIN
for resized in pyramid(img, scaleFactor):
scale = float(img.shape[1]) / float(resized.shape[1])
for (x, y, roi) in sliding_window(resized, 20, (100, 40)):
if roi.shape[1] != w or roi.shape[0] != h:
continue
try:
bf = bow_features(roi, extractor, detect)
_, result = svm.predict(bf)
a, res = svm.predict(bf, flags=cv2.ml.STAT_MODEL_RAW_OUTPUT | cv2.ml.STAT_MODEL_UPDATE_MODEL)
print "Class: %d, Score: %f, a: %s" % (result[0][0], res[0][0], res)
score = res[0][0]
if result[0][0] == 1:
if score < -1.0:
rx, ry, rx2, ry2 = int(x * scale), int(y * scale), int((x+w) * scale), int((y+h) * scale)
rectangles.append([rx, ry, rx2, ry2, abs(score)])
except:
pass
counter += 1
windows = np.array(rectangles)
boxes = nms(windows, 0.25)
for (x, y, x2, y2, score) in boxes:
print x, y, x2, y2, score
cv2.rectangle(img, (int(x),int(y)),(int(x2), int(y2)),(0, 255, 0), 1)
cv2.putText(img, "%f" % score, (int(x),int(y)), font, 1, (0, 255, 0))
cv2.imshow("img", img)
cv2.waitKey(0)
Python解释器会将带有 yield的函数其视为一个generator,看起来像函数调用,但不会执行任何函数代码,直到对其调用next()(在 for 循环中会自动调用next())才开始执行,每执行到一个yield语句就会中断,并返回一个迭代值,下次执行时从yield的下一个语句继续执行
通过指定的因子来调整图像大小 建立图像金字塔
pyramid.py
import cv2
def resize(img, scaleFactor):
return cv2.resize(img, (int(img.shape[1] * (1 / scaleFactor)), int(img.shape[0] * (1 / scaleFactor))), interpolation=cv2.INTER_AREA)
def pyramid(image, scale=1.5, minSize=(200, 80)):
yield image #yield 生成器
while True:
image = resize(image, scale)
if image.shape[0] < minSize[1] or image.shape[1] < minSize[0]:
break
yield image
滑动窗口
sliding_window.py
def sliding_window(image, step, window_size):
for y in xrange(0, image.shape[0], step):#高 #xrange生成的不是一个list对象,而是一个生成器
for x in xrange(0, image.shape[1], step):#宽
yield (x, y, image[y:y + window_size[1], x:x + window_size[0]])
non_maximum.py
import numpy as np
def non_max_suppression_fast(boxes, overlapThresh):
# if there are no boxes, return an empty list
if len(boxes) == 0:
return []
# if the bounding boxes integers, convert them to floats --
# this is important since we'll be doing a bunch of divisions
if boxes.dtype.kind == "i":
boxes = boxes.astype("float")
# initialize the list of picked indexes
pick = []
# grab the coordinates of the bounding boxes
x1 = boxes[:,0]
y1 = boxes[:,1]
x2 = boxes[:,2]
y2 = boxes[:,3]
scores = boxes[:,4]
# compute the area of the bounding boxes and sort the bounding
# boxes by the score/probability of the bounding box
area = (x2 - x1 + 1) * (y2 - y1 + 1)
idxs = np.argsort(scores)#返回下标列表 顺序 从小到大的列表
#idxs = idxs[::-1] 逆序
# keep looping while some indexes still remain in the indexes
# list
while len(idxs) > 0:
# grab the last index in the indexes list and add the
# index value to the list of picked indexes
last = len(idxs) - 1
i = idxs[last]
pick.append(i)#用于保存scores最大的下标
# find the largest (x, y) coordinates for the start of
# the bounding box and the smallest (x, y) coordinates
# for the end of the bounding box
#计算两个box的重叠区域,x1和y1取两box间大的, x2和y2取两box间小的
xx1 = np.maximum(x1[i], x1[idxs[:last]])#np.maximum(x,y) X与Y逐位比较取其大者
yy1 = np.maximum(y1[i], y1[idxs[:last]])
xx2 = np.minimum(x2[i], x2[idxs[:last]])#取其小者
yy2 = np.minimum(y2[i], y2[idxs[:last]])
# compute the width and height of the bounding box
w = np.maximum(0, xx2 - xx1 + 1)#无重叠区域(负值)置为0
h = np.maximum(0, yy2 - yy1 + 1)
# compute the ratio of overlap
overlap = (w * h) / area[idxs[:last]]
# delete all indexes from the index list that have
#删除得分最高的box及overlap大于阈值的box,剩余的box继续进行上述过程
idxs = np.delete(idxs, np.concatenate(([last],np.where(overlap > overlapThresh)[0])))
#numpy.where(condition, [x, y])#当conditon的某个位置的为true时,输出x的对应位置的元素,否则选择y对应位置的元素;如果只有参数condition,则函数返回为true的元素的坐标位置信息
#np.concatenate((a,b,c),axis=0) 0按行拼接 1按列拼接
#例np.delete(x,[1,4],axis=0)删除x的1、4行 axis=1 删除1、4列
# return only the bounding boxes that were picked using the
# integer data type
return boxes[pick].astype("int")
detector.py
import cv2
import numpy as np
datapath = "CarData/TrainImages"
SAMPLES = 129
def path(cls,i):
return "%s/%s%d.pgm" % (datapath,cls,i+1)
def get_flann_matcher():
flann_params = dict(algorithm = 1, trees = 5)
return cv2.FlannBasedMatcher(flann_params, {})
def get_bow_extractor(extract, match):
return cv2.BOWImgDescriptorExtractor(extract, match)
def get_extract_detect():
return cv2.xfeatures2d.SIFT_create(), cv2.xfeatures2d.SIFT_create()
def extract_sift(fn, extractor, detector):
im = cv2.imread(fn,0)
return extractor.compute(im, detector.detect(im))[1]
def bow_features(img, extractor_bow, detector):
return extractor_bow.compute(img, detector.detect(img))
def car_detector():
pos, neg = "pos-", "neg-"
detect, extract = get_extract_detect()
matcher = get_flann_matcher()
#extract_bow = get_bow_extractor(extract, matcher)
print "building BOWKMeansTrainer..."
bow_kmeans_trainer = cv2.BOWKMeansTrainer(12)
extract_bow = cv2.BOWImgDescriptorExtractor(extract, matcher)
print "adding features to trainer"
for i in range(SAMPLES):
print i
bow_kmeans_trainer.add(extract_sift(path(pos,i), extract, detect))
bow_kmeans_trainer.add(extract_sift(path(neg,i), extract, detect))
vocabulary = bow_kmeans_trainer.cluster()
extract_bow.setVocabulary(vocabulary)
traindata, trainlabels = [],[]
print "adding to train data"
for i in range(SAMPLES):
print i
traindata.extend(bow_features(cv2.imread(path(pos, i), 0), extract_bow, detect))
trainlabels.append(1)
traindata.extend(bow_features(cv2.imread(path(neg, i), 0), extract_bow, detect))
trainlabels.append(-1)
svm = cv2.ml.SVM_create()
svm.setType(cv2.ml.SVM_C_SVC)
svm.setGamma(1)
svm.setC(35)
svm.setKernel(cv2.ml.SVM_RBF)
svm.train(np.array(traindata), cv2.ml.ROW_SAMPLE, np.array(trainlabels))
return svm, extract_bow