def feature_hog_desc(img):
winSize = (img_rows, img_cols)
blockSize = (112, 112)
blockStride = (7, 7)
cellSize = (56, 56)
nbins = 9
derivAperture = 1
winSigma = -1.
histogramNormType = 0
L2HysThreshold = 0.2
gammaCorrection = 0
nlevels = 64
useSignedGradients = True
#img = Dilated_Canny(img)
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins,
derivAperture, winSigma, histogramNormType,
L2HysThreshold, gammaCorrection, nlevels,
useSignedGradients)
descriptor = hog.compute(img)
print(descriptor)
print(descriptor.shape)
return descriptor
def hog_compute(img, p):
width, height, depth = img.shape
win_size = p.w # Decrease length of output
block_size = p.b # In pixels
block_stride = p.b_stride # In pixels
cell_size = p.c # In pixels
nbins = p.nbins
deriv_aperture = p.aperture
win_sigma = p.sigma
histogram_norm_type = p.norm
threshold = p.t
gamma_correction = p.g
nlevels = p.nlevels
hog = cv2.HOGDescriptor(win_size, block_size, block_stride, cell_size,
nbins, deriv_aperture, win_sigma,
histogram_norm_type, threshold,
gamma_correction, nlevels)
hog.save("hog.xml")
win_stride = p.w_stride # Not affecting length of output
padding = p.padding
hist = hog.compute(img, win_stride,
padding) # Omit locations to compute whole image
return hist
def train():
hog = getHOG()
dataset = []
datalabels = []
folderCount = 0
folderList = getFolderList("Training")
dataCount = 0
while folderCount < len(folderList):
imageCount = 0
imageList, prop = loadImages(folderList[folderCount])
classId = prop[0][-1]
while imageCount < len(imageList):
new_img = cv2.imread(folderList[folderCount] + prop[imageCount][0])
new_img = resize(new_img, None)
des = hog.compute(new_img)
dataset.append(des)
datalabels.append(int(classId))
# print(int(classId))
# cv2.imshow('frame', new_img)
# if cv2.waitKey(1) & 0xFF == ord('q'):
# break
imageCount = imageCount + 1
dataCount = dataCount + 1
# print(imageCount)
folderCount = folderCount + 1
cv2.destroyAllWindows()
# print('dataset', len(dataset))
# rbf gamm = 0.9 c =5
# Set up SVM for OpenCV 3
svm = cv2.ml.SVM_create()
# Set SVM type
svm.setType(cv2.ml.SVM_C_SVC)
# Set SVM Kernel to Radial Basis Function (RBF)
svm.setKernel(cv2.ml.SVM_POLY)
# det degree
svm.setDegree(2.5)
# Set parameter C
svm.setC(12.5)
# Set parameter Gamma
svm.setGamma(0.030625)
# Train SVM on training data
dataset = np.squeeze(np.array(dataset))
print(dataset.shape)
datalabels = np.array(datalabels)
svm.train(dataset, cv2.ml.ROW_SAMPLE, datalabels)
# Save trained model
svm.save("Models/svm.dat")
print("Training Done")
return svm
def gaindata(filepath):
label = []
data = []
winSize = (168, 192)
blockSize = (16, 16)
blockStride = (8, 8)
cellSize = (8, 8)
nbins = 9
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins)
# hog = cv2.HOGDescriptor()
for root, dirs, files in os.walk(filepath):
print(root)
datasingle = []
if root == "/home/dzd/dzd/labwork/face/yaleBExtData":
continue
for file in files:
hog_data = []
img = cv2.imread(os.path.join(root, file), cv2.IMREAD_GRAYSCALE)
label.append(int(root[-2:]))
if (img.size != 32256):
img.resize(192, 168)
# img.resize(48,42)
hog_descriptor = hog.compute(img)
for i in range(len(hog_descriptor)):
hog_data.append(hog_descriptor[i][0])
# img.resize(1,48*42)
# datasingle.append(img[0]/255.0)
datasingle.append(hog_data)
data.append(datasingle)
return label, data
def test(svm):
hog = getHOG()
dataset = []
datalabels = []
folderCount = 0
folderList = getFolderList("Testing")
dataCount = 0
imageCount = 0
'''
## Dark image test case --------------------------------------------------------------
a = np.zeros((64,64,3), dtype = np.uint8)
b = []
for i in range(3):
new_img = resize(a[0], None)
des = hog.compute(new_img)
b.append(des)
'''#----------------------------------------------------------------------------------
while folderCount < len(folderList):
print('folder count', folderCount)
imageCount = 0
imageList, prop = loadImages(folderList[folderCount])
if not imageList:
folderCount = folderCount + 1
continue
classId = prop[0][-1]
while imageCount < len(imageList):
new_img = cv2.imread(folderList[folderCount] + prop[imageCount][0])
new_img = resize(new_img, prop[imageCount])
des = hog.compute(new_img)
dataset.append(des)
datalabels.append(int(classId))
cv2.imshow('frame', new_img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
imageCount = imageCount + 1
dataCount = dataCount + 1
folderCount = folderCount + 1
cv2.destroyAllWindows()
dataset = np.squeeze(np.array(dataset))
testResponse = svm.predict(dataset)[1].ravel()
count = 0
for i in range(len(testResponse)):
if (testResponse[i] - datalabels[i]) != 0.0:
print('Test Value:', testResponse[i])
print('Actual Value:', datalabels[i])
count = count + 1
print(np.array(testResponse))
print(datalabels)
percentage = float(len(datalabels)-count)/(len(datalabels))*100
print('Percentage: ', float(len(datalabels)-count)/(len(datalabels))*100)
print('unique responses: ',np.unique(testResponse))
return percentage
def getDescriptor(sample,expected_shape=(128,64) ,descr_open_cv=False,name='LBPH'):
sampleToPredict = pre_process(sample,expected_shape)
descr = None
if(descr_open_cv):
if name=='ORB':
descr_sz = 64
descr = np.zeros(descr_sz) # tamanho max baseado em experimento
orb = cv2.ORB_create(nfeatures=descr_sz)
kp = orb.detect(sampleToPredict,None)
kp,orb_desc = orb.compute(sampleToPredict,kp)
if orb_desc is not None:
orb_desc = orb_desc.ravel()
for i in range(orb_desc.shape[0]):
if i < descr_sz:
descr[i] = orb_desc[i]
else:
break
elif name=='HOG_OPENCV':
hog = cv2.HOGDescriptor()
descr = hog.compute(sampleToPredict) #opencv hog
descr = np.squeeze(descr)
else:
if name=='HOG_SKIMAGE':
descr =hog(sampleToPredict,orientations=8,pixels_per_cell=(4,4),
cells_per_block=(1,1),visualize=False,multichannel=False) #skimage hog
elif name=='LBPH':
descr = local_binary_pattern(image=sampleToPredict,P=8,R=1,method='default')
descr = descr.ravel()
hist,_ = np.histogram(descr,bins=np.arange(256),density=True)
descr = hist
return descr
def get_hogcv_feature(img, label):
winsize = 12
winSize = (winsize, winsize)
blockSize = (int(winsize / 2), int(winsize / 2))
blockStride = (int(winsize / 4), int(winsize / 4))
cellSize = (int(winsize / 4), int(winsize / 4))
#cellSize = (3,3)
nbins = 10
derivAperture = 3
winSigma = 4.
histogramNormType = 0
L2HysThreshold = 0.5
gammaCorrection = 0
nlevels = 72
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins,
derivAperture, winSigma, histogramNormType,
L2HysThreshold, gammaCorrection, nlevels)
winStride = (int(winsize / 4), int(winsize / 4))
padding = (int(winsize / 4), int(winsize / 4))
locations = train_tool.windingSystemTrainTool_class().getHogLocations(
img.shape[1], img.shape[0], winsize)
features = hog.compute(img, winStride, padding, locations).flatten()
fd = np.concatenate((features, [label]))
return fd
def extract_hog(samples):
"""
从训练数据集中提取HOG特征，并返回
:param samples: 训练数据集
:return train: 从训练数据集中提取的HOG特征
"""
train = []
print("正在提取HOG特征......")
num = 0.
total = len(samples)
for f in samples:
num += 1.
print('正在处理{} {:2.1f}%'.format(f, num / total * 100))
# HOG参数 winSize, blockSize, blockStride, cellSize, nbins
# hog = cv2.HOGDescriptor((64, 128), (16, 16), (8, 8), (8, 8), 9)
img = cv2.imread(f, -1)
# img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 灰度化
img = cv2.resize(img, (64, 128))
hog = cv2.HOGDescriptor((64, 128), (16, 16), (8, 8), (8, 8), 9)
feature = hog.compute(img)
# feature = hog(img, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(4, 4), block_norm="L1")
# descriptors = hog.compute(img) # 计算特征向量
train.append(feature)
train = np.float32(train)
train = np.resize(train, (total, 3780))
return train
def hog_descriptor_opencv(image, shape):
win_size = shape
block_size = (int(shape[0] / 8), int(shape[0] / 8))
block_stride = (int(shape[0] / 8), int(shape[0] / 8))
cell_size = (int(shape[0] / 8), int(shape[0] / 8))
orientation_bins = 9
hog = cv2.HOGDescriptor(win_size, block_size, block_stride, cell_size, orientation_bins)
return hog.compute(image)
def train_traffic_signs(name):
hog = getHOG()
dataset = []
datalabels = []
folderCount = 5
folderList = getFolderList("Training")
dataCount = 0
while folderCount < len(folderList):
imageCount = 0
imageList, prop = loadImages(folderList[folderCount])
classId = prop[0][-1]
while imageCount < len(imageList):
new_img = cv2.imread(folderList[folderCount] + prop[imageCount][0])
new_img = resize(new_img, prop[imageCount])
des = hog.compute(new_img)
dataset.append(des)
datalabels.append(int(1))
cv2.imshow('frame', new_img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
imageCount = imageCount + 1
dataCount = dataCount + 1
folderCount = folderCount + 1
cv2.destroyAllWindows()
# Set up SVM for OpenCV 3
svm = cv2.ml.SVM_create()
# Set SVM type
svm.setType(cv2.ml.SVM_ONE_CLASS)
# Set SVM Kernel to Radial Basis Function (RBF)
svm.setKernel(cv2.ml.SVM_POLY)
# det degree
svm.setDegree(2.5)
# Set parameter C
svm.setC(3)
svm.setP(0)
svm.setCoef0(0)
svm.setNu(.5)
# Set parameter Gamma
svm.setGamma(1)
# Train SVM on training data
dataset = np.squeeze(np.array(dataset))
datalabels = np.array(datalabels)
svm.train(dataset, cv2.ml.ROW_SAMPLE, datalabels)
# Save trained model
svm.save('Models/' + name + '.dat')
print("Training Done")
return svm
def HOG(image):
winSize = (64,128)
blockSize = (16,16)
cellSize = (8,8)
blockStride = (8,8)
nbins = 9
hog = cv2.HOGDescriptor(winSize,blockSize,blockStride,cellSize,nbins)
h = hog.compute(image)
return h
def feature_extract(img, mask):
hog = cv.HOGDescriptor((640, 480), (16, 16), (8, 8), (8, 8), 9, 4, 0.2, 1,
64)
mask = cv.morphologyEx(mask,
cv.MORPH_OPEN,
kernel=cv.getStructuringElement(
cv.MORPH_RECT, (4, 4)))
mask = cv.medianBlur(mask, 7)
mask = cv.medianBlur(mask, 5)
mask = cv.medianBlur(mask, 3)
mask, conts, _ = cv.findContours(mask, cv.RETR_EXTERNAL,
cv.CHAIN_APPROX_SIMPLE)
mask = img * mask[:, :, None].astype(img.dtype)
mask = cv.drawContours(mask, conts, -1, (0, 255, 0), 3)
#fd, hog_image = hog(mask, orientations=9, pixels_per_cell=(16, 16), cells_per_block=(1, 1), visualise=True)
return hog.compute(mask)
def rodaHOG(original_image):
# https://www.learnopencv.com/histogram-of-oriented-gradients/
# https://www.learnopencv.com/handwritten-digits-classification-an-opencv-c-python-tutorial/
winSize = (20, 20)
blockSize = (10, 10)
blockStride = (5, 5)
cellSize = (2, 2)
nbins = 9
derivAperture = 1
winSigma = -1.
histogramNormType = 0
L2HysThreshold = 0.2
gammaCorrection = 1
nlevels = 64
signedGradients = True
# regra para valores (altura/largura): (winSize - blockSize) % blockStride == 0
# Cria descritor
hog = cv.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins,
derivAperture, winSigma, histogramNormType,
L2HysThreshold, gammaCorrection, nlevels,
signedGradients)
# descriptor = hog.compute(original_image, winStride=(64, 128), padding=(0, 0))
array = np.array([]) # empty array for storing all the features
# h = 128 # height of the image
# w = 64 # width of the image
# cv.imshow('Image', original_image)
# img = cv.resize(original_image, (w, h), interpolation=cv.INTER_CUBIC) # resize images
# cv.imshow('Image', img)
h = hog.compute(original_image, winStride=(64, 128),
padding=(0, 0)) # storing HOG features as column vector
# h = hog.compute(original_image) # storing HOG features as column vector
# # hog_image_rescaled = exposure.rescale_intensity(h, in_range=(0, 0.02))
# # plt.figure(1, figsize=(3, 3))
# # plt.imshow(h,cmap=plt.cm.gray)
# # plt.show()
# # print len(h)
h_trans = h.transpose() # transposing the column vector
arrayHOG = np.vstack(h_trans) # appending it to the array
print("HOG features of label 1")
print(arrayHOG)
def extractHOGfeatures(img, detector):
winSize = (64, 64)
blockSize = (16, 16)
blockStride = (8, 8)
cellSize = (8, 8)
nbins = 9
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins)
kpts = detector.detect(img)
loc = [(int(x.pt[0]), int(x.pt[1])) for x in kpts]
loc = tuple(loc)
fd = hog.compute(img, hog.blockStride, hog.cellSize, loc)
#fd = hog(img,
# orientations=cfg.hog_orientations,
# pixels_per_cell=cfg.hog_pixels_per_cell,
# cells_per_block=cfg.hog_cells_per_block,
# visualise=False,
return fd
def validateBox(image,corners, mode):
img = np.copy(image)
roi = img[corners[1]:corners[3], corners[0]:corners[2]] # xmin, ymin, xmax, yax
width = 64
height = 64
dim = (width, height)
hog = getHOG()
resized_img = cv2.resize(roi, dim, interpolation = cv2.INTER_AREA)
des = hog.compute(resized_img)
dataset = np.squeeze(np.array(des)).reshape((1,-1))
response = computeClass(dataset, mode)
print(response)
if not response == -1:
text = str(response)
cv2.rectangle(image, (corners[0], corners[1]), (corners[2], corners[3]), (0,255,0), 2)
cv2.putText(image, text, (corners[0], corners[3]+25 ), cv2.FONT_HERSHEY_SCRIPT_SIMPLEX, 1.0, (0,255,0), 2)
return image
def testcv2hog():
im = cv2.imread("data/video_1_59.jpg") # 8x8? cell size
im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
hog = cv2.HOGDescriptor(_winSize=(256, 256),
_blockSize=(16, 16),
_blockStride=(8, 8),
_cellSize=(8, 8),
_nbins=9)
features = hog.compute(im)
print(len(features))
# testskimagehog()
# testcv2hog()
#testhaar('svmdata/yalefaces_jpg')
def hogCV(self, image, param):
winSize = (param.resize_width, param.resize_height)
blockSize = (param.block_size, param.block_size)
blockStride = (param.cell_size, param.cell_size)
cellSize = (param.cell_size, param.cell_size)
nbins = param.bins
signedGradient = param.signed_gradient
derivAperture = 1
winSigma = 4.
histogramNormType = 0
L2HysThreshold = 2.0000000000000001e-01
gammaCorrection = 0
nlevels = 64
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize,
nbins, derivAperture, winSigma,
histogramNormType, L2HysThreshold,
gammaCorrection, nlevels, signedGradient)
h = hog.compute(image)
return h
def classifier(image, hog, model):
TRAINING_IMAGE_SIZE_X = 64
TRAINING_IMAGE_SIZE_Y = 64
# convert to grayscale
trainImage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# resize
trainImage = cv2.resize(trainImage,
(TRAINING_IMAGE_SIZE_X, TRAINING_IMAGE_SIZE_Y),
interpolation=cv2.INTER_AREA)
# We have to tune these
# fd = hog.compute(trainImage,winStride,padding,locations)
fd = hog.compute(trainImage)
fd = fd.T
y_pred = model.predict(fd)
# print 'Class is :',y_pred
return y_pred[0]
def extractHOG(img,
orient,
pix_per_cell,
cell_per_block,
vis=False,
feature_vec=True):
if vis == True:
features, hog_image = hog(img,
orientations=orient,
pixels_per_cell=(pix_per_cell, pix_per_cell),
cells_per_block=(cell_per_block,
cell_per_block),
transform_sqrt=False,
visualise=True,
feature_vector=False)
return features, hog_image
else:
#Parameter Hardcoded for final version
hog = cv2.HOGDescriptor((64, 64), (8, 8), (8, 8), (8, 8), 9)
features = hog.compute(img)
return np.ravel(features)
def hog_of_digit(self, image):
winSize = (20, 20)
blockSize = (10, 10)
blockStride = (5, 5)
cellSize = (10, 10)
nbins = 9
derivAperture = 1
winSigma = -1.
histogramNormType = 0
L2HysThreshold = 0.2
gammaCorrection = 1
nlevels = 64
useSignedGradients = True
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize,
nbins, derivAperture, winSigma,
histogramNormType, L2HysThreshold,
gammaCorrection, nlevels, useSignedGradients)
# hog = cv2.HOGDescriptor()
descriptor = hog.compute(image)
return descriptor
def hog_descriptor_2(digit):
winSize = (20, 20)
blockSize = (10, 10)
blockStride = (5, 5)
cellSize = (10, 10)
nbins = 9
derivAperture = 1
winSigma = -1.
histogramNormType = 0
L2HysThreshold = 0.2
gammaCorrection = 1
nlevels = 64
signedGradients = True
hog = cv.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins,
derivAperture, winSigma, histogramNormType,
L2HysThreshold, gammaCorrection, nlevels,
signedGradients)
descriptors = hog.compute(digit)
return descriptors
def hog2(image):
winSize = (4, 4)
blockSize = (2, 2)
blockStride = (1, 1)
cellSize = (2, 2)
nbins = 9
derivAperture = 1
winSigma = -1.
histogramNormType = 0
L2HysThreshold = 0.2
gammaCorrection = 1
nlevels = 4
signedGradients = True
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins,
derivAperture, winSigma, histogramNormType,
L2HysThreshold, gammaCorrection, nlevels,
signedGradients)
descriptor = hog.compute(image)
print('tam:', descriptor.shape)
return descriptor
def hog(l1):
winSize = (64, 64)
blockSize = (16, 16)
blockStride = (8, 8)
cellSize = (8, 8)
nbins = 9
derivAperture = 1
winSigma = 4.
histogramNormType = 0
L2HysThreshold = 2.0000000000000001e-01
gammaCorrection = 0
nlevels = 64
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins,
derivAperture, winSigma, histogramNormType,
L2HysThreshold, gammaCorrection, nlevels)
# compute(img[, winStride[, padding[, locations]]]) -> descriptors
winStride = (8, 8)
padding = (8, 8)
locations = ((10, 20), )
l1 = np.array(l1, dtype='uint8')
result = [hog.compute(img, winStride, padding, locations) for img in l1]
# Rescale histogram for better display
# hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 10))
return result
#Step 1: Sample P positive samples from your training data of #the object(s) you want to detect and extract HOG descriptors from these samples. import matplotlib.pyplot as plt from skimage.feature import hog from skimage import data, color, exposure from config import roadtemp, road1, road2, road3, road4, road5, road6, road7, road8, road9, road10 from PIL import Image import numpy as np import cv2 im_list = [roadtemp, road1, road2, road3, road4, road5, road6, road7, road8] hog_image_list = [] test_image_list = [road9, road10] test_hog_image_list = [] for element in im_list: hog = cv2.HOGDescriptor() im = cv2.imread(element) h = hog.compute(im) hog_image_list.append(h) for element2 in test_image_list: hog = cv2.HOGDescriptor() im = cv2.imread(element2) h = hog.compute(im) test_hog_image_list.append(h)
# load training image
image = cv2.imread(imagePath)
# convert to grayscale
trainImage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# resize
trainImage = cv2.resize(trainImage,
(TRAINING_IMAGE_SIZE_X, TRAINING_IMAGE_SIZE_Y),
interpolation=cv2.INTER_AREA)
# showImage(trainImage)
# We have to tune these
# fd = hog.compute(trainImage,winStride,padding,locations)
fd = hog.compute(trainImage)
fd = fd.T
if nImageCounter == 1:
trainingFeaturesArr = fd
trainingLabelsArr = np.array(1)
else:
trainingFeaturesArr = np.vstack((trainingFeaturesArr, fd))
trainingLabelsArr = np.append(trainingLabelsArr, 1)
if nImageCounter >= nImagesCutoff:
break
if nImageCounter >= nImagesCutoff:
break
nPostiveImages = nImageCounter
nImageCounter = 0
cv2.CV_16S,
0,
1,
ksize=3,
scale=1,
delta=0),
size=(TAMANHO_X, TAMANHO_Y))
sobeldXY = image_to_feature_vector(cv2.Sobel(image,
cv2.CV_16S,
1,
1,
ksize=3,
scale=1,
delta=0),
size=(TAMANHO_X, TAMANHO_Y))
hogimage = image_to_feature_vector(hog.compute(image),
size=(TAMANHO_X, TAMANHO_Y))
rawImages.append(pixels)
descHist.append(histogram)
descEdges.append(edges)
descSobelX.append(sobeldx)
descSobelY.append(sobeldy)
descSobelXY.append(sobeldXY)
descHOG.append(hogimage)
if i % 250 == 0:
print('Processed {} of {}'.format(i, count))
pickelObject(rawImages, 'rawImagesPickel')
pickelObject(descHist, 'descHistPickel')
pickelObject(descEdges, 'descEdgesPickel')
pickelObject(descSobelX, 'descSobelXPickel')
cellSize = (16, 16)
nbins = 9
derivAperture = 1
winSigma = 4.
histogramNormType = 0
L2HysThreshold = 2.0000000000000001e-01
gammaCorrection = 0
nlevels = 64
hog = cv2.HOGDescriptor(winSize, blockSize, blockStride, cellSize, nbins,
derivAperture, winSigma, histogramNormType,
L2HysThreshold, gammaCorrection, nlevels)
#compute(img[, winStride[, padding[, locations]]]) -> descriptors
winStride = (8, 8)
padding = (8, 8)
locations = ((10, 20), )
hist = hog.compute(image) #,winStride,padding,locations)
print("histogram computed")
print("type of hist is: " + str(type(hist)))
print("size of hist is: " + str(hist.size))
print("shape of hist is: " + str(hist.shape))
hog_im = ord_hist(hist, nbins)
hog_im = vis_hist(hog_im, image, 16, 16)
#hog_im = exposure.rescale_intensity(hog_im, in_range=(0, 100))
hog_im = shrink_image(45, hog_im)
cv2.imshow("image gradients", hog_im)
cv2.waitKey(0)
#cv2.destroyAllWindows()
#image is the current frame
success, image = vidcapture.read()
imagePrev = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
imagePrev = cv2.resize(imagePrev, (64, 128))
#count of frames captured
framesCount = 0
#success will be false when there's no frames left to read
success = True
while success:
success, image2 = vidcapture.read()
#Skipping 3 frames
if framesCount % 6 == 0 and success == True:
imageNext = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
imageNext = cv2.resize(imageNext, (64, 128))
videoFrames.append(hog.compute(imageNext))
listOfFrameLabels.append(folderIndex)
#creating a 9-valued bin for current cell
cellBin = [0, 0, 0, 0, 0, 0, 0, 0, 0]
for windowHeight in range(0, imageNext.shape[0],
windowsize_width):
for windowWidth in range(0, imageNext.shape[1],
windowsize_height):
windowPrev = imagePrev[windowHeight:windowHeight +
windowsize_height,
windowWidth:windowWidth +
windowsize_width]
windowNext = imageNext[windowHeight:windowHeight +
windowsize_height,
windowWidth:windowWidth +
img = cv2.cvtColor(im1, cv2.COLOR_RGB2HLS)
cell_size = (8, 8) # h x w in pixels
block_size = (2, 2) # h x w in cells
nbins = 9 # number of orientation bins
# winSize is the size of the image cropped to an multiple of the cell size
hog = cv2.HOGDescriptor(_winSize=(img.shape[1] // cell_size[1] * cell_size[1],
img.shape[0] // cell_size[0] * cell_size[0]),
_blockSize=(block_size[1] * cell_size[1],
block_size[0] * cell_size[0]),
_blockStride=(cell_size[1], cell_size[0]),
_cellSize=(cell_size[1], cell_size[0]),
_nbins=nbins)
h = hog.compute(img[:, :, 1])
n_cells = (img.shape[0] // cell_size[0], img.shape[1] // cell_size[1])
hog_feats = hog.compute(img)\
.reshape(n_cells[1] - block_size[1] + 1,
n_cells[0] - block_size[0] + 1,
block_size[0], block_size[1], nbins) \
.transpose((1, 0, 2, 3, 4)) # index blocks by rows first
gradients = np.zeros((n_cells[0], n_cells[1], nbins))
# count cells (border cells appear less often across overlapping groups)
cell_count = np.full((n_cells[0], n_cells[1], 1), 0, dtype=int)
for off_y in range(block_size[0]):
for off_x in range(block_size[1]):
gradients[off_y:n_cells[0] - block_size[0] + off_y + 1,
off_x:n_cells[1] - block_size[1] + off_x + 1] += \
false_positives = []
# loop over the image pyramid
for resized in pyramid(image, scale=1.5):
# loop over the sliding window for each layer of the pyramid
for (x, y, window) in sliding_window(resized, stepSize=32, windowSize=(winW, winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
# print window.shape[0], window.shape[1]
continue
# THIS IS WHERE YOU WOULD PROCESS YOUR WINDOW, SUCH AS APPLYING A
# MACHINE LEARNING CLASSIFIER TO CLASSIFY THE CONTENTS OF THE
# WINDOW
hog = cv2.HOGDescriptor()
h = hog.compute(resized)
print(h)
prediciton = lin_svc.predict(h.reshape(1,-1))
print(prediciton)
# threshold = 0.4
# loc = np.where( h >= threshold)
# print(loc)
# # since we do not have a classifier, we'll just draw the window
clone = resized.copy()
cv2.rectangle(clone, (x,y), (x + 130, y + 130), (0, 255, 0), 2)
cv2.imshow("Window", clone)
cv2.waitKey(1)
def training(path,train,labels): tame = 0 winSize = (64,64) blockSize = (16,16) blockStride = (8,8) cellSize = (8,8) nbins = 9 derivAperture = 1 winSigma = 4. histogramNormType = 0 L2HysThreshold = 2.0000000000000001e-01 gammaCorrection = 0 nlevels = 64 winStride = (8,8) padding = (8,8) locations = ((10,20),) hog = cv2.HOGDescriptor(winSize,blockSize,blockStride,cellSize,nbins,derivAperture,winSigma, histogramNormType,L2HysThreshold,gammaCorrection,nlevels) for root, dir_names, file_names in os.walk(path): for path in dir_names: training(os.path.join(root, path),train,labels) for file_name in file_names: file_path = os.path.join(root, file_name) if not file_path in names and file_name[-3:-1] =='jp': if file_name[-3:-1] == 'jp' : #print file_name[7:-4] if file_name[7] == 'B': labels.append(1) if file_name[7] == 'C' : labels.append(3) if file_name[7] == 'P': labels.append(4) if file_name[7] == 'N' : labels.append(5) if file_name[7] == 'M' : labels.append(2) #print file_path image = cv2.imread(file_path,0) lists = [] hist = hog.compute(image,winStride,padding,locations) for i in range(0, len(hist)) : lists.append( hist[i][0]) train.append(lists) tame = tame + 1 #fd =hog(c, orientations=9, pixels_per_cell=(len(image)/size, (len(image[0]))/size), cells_per_block=(1, 1), visualise=False) #for i in len(image) : #train.append(fd) #print (fd) return tame
winSize = (64,64)
blockSize = (16,16)
blockStride = (8,8)
cellSize = (8,8)
nbins = 9
derivAperture = 1
winSigma = 4.
histogramNormType = 0
L2HysThreshold = 2.0000000000000001e-01
gammaCorrection = 0
nlevels = 64
winStride = (8,8)
padding = (8,8)
locations = ((10,20),)
hog = cv2.HOGDescriptor(winSize,blockSize,blockStride,cellSize,nbins,derivAperture,winSigma, histogramNormType,L2HysThreshold,gammaCorrection,nlevels)
hist = hog.compute(image,winStride,padding,locations)
lists = []
for i in range(0, len(hist)) :
lists.append( hist[i][0])
finale = []
finale.append(lists)
clf.fit(train,labels)
# filename = '/digits_classifier.joblib.pkl'
# _ = joblib.dump(clf, filename, compress=9)
with open('kane.pkl', 'wb') as f:
pickle.dump(clf, f)
def calculate_hog(hog, img):
h = hog.compute(img)
npNumber = np.zeros(h.shape[0], dtype=np.float)
for i in range(0, h.shape[0]):
npNumber[i]=h[i]
return npNumber
