py4CV例子2汽车检测和svm算法

flann_params = dict( algorithm = 1, trees = 5)

matcher = cv2.FlannBasedMatcher(flann_params, {})

def extract_sift( fn):

im = cv2.imread(fn, 0)

return extract.compute(im, detect.detect(im))[ 1]

for i in range( 8):

bow_kmeans_trainer.add(extract_sift(path(pos,i)))

bow_kmeans_trainer.add(extract_sift(path(neg,i)))

voc = bow_kmeans_trainer.cluster()

extract_bow.setVocabulary( voc )

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)

traindata.extend(bow_features(path(neg, i))); trainlabels.append(- 1)

svm = cv2.ml.SVM_create()

svm.train(np.array(traindata), cv2.ml.ROW_SAMPLE, np.array(trainlabels))

def predict( fn):

f = bow_features(fn);

p = svm.predict(f)

print(fn, " \t ", p[ 1][ 0][ 0])

return p

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

while True:

image = resize(image, scale)

if image.shape[ 0] < minSize[ 1] or image.shape[ 1] < minSize[ 0]:

break

yield image

def sliding_window( image, step, window_size):

for y in xrange( 0, image.shape[ 0], step):

for x in xrange( 0, image.shape[ 1], step):

yield (x, y, image[y:y + window_size[ 1], x:x + window_size[ 0]])

# import the necessary packages

import numpy as np

# Malisiewicz et al.

# Python port by Adrian Rosebrock

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)[::- 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)

# 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

xx1 = np.maximum(x1[i], x1[idxs[:last]])

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)

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

idxs = np.delete(idxs, np.concatenate(([last],

np.where(overlap > overlapThresh)[ 0])))

# return only the bounding boxes that were picked using the

# integer data type

return boxes[pick].astype( "int")

datapath = "E:/py4cv/CarData/TrainImages"

SAMPLES = 400

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))

import cv2

import numpy as np

datapath = "E:/py4cv/CarData/TrainImages"

SAMPLES = 400

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-"

#获得两个sift的检测器

detect, extract = get_extract_detect()

#获得flann的描述符

matcher = get_flann_matcher()

#创建bow描述检测器

print( "building BOWKMeansTrainer...")

bow_kmeans_trainer = cv2.BOWKMeansTrainer( 12)

extract_bow = cv2.BOWImgDescriptorExtractor(extract, matcher)

#首先构建bow词典

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)

#基于词汇进行svm训练

traindata, trainlabels = [],[]

print "adding to train data"

for i in range(SAMPLES):

print i

#1为有数据，-1为没有数据

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_linear 超平面 两类；svm_rbf高斯核，多类

svm.train(np.array(traindata), cv2.ml.ROW_SAMPLE, np.array(trainlabels))

return svm, extract_bow

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

img_path = "E:/sandbox/car1.png"

#获得svm模型训练结果。注意在训练过程中没有使用滑动窗口

svm, extractor = car_detector()

detect = cv2.xfeatures2d.SIFT_create()

w, h = 100, 40

img = cv2.imread(img_path)

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)): #窗口大小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)