def lbp_classifier():
img_gallery, y_gallery = load_gan_gallery()
lra_train = np.array([calHistogram(lbp(img,8,2),16,16) for img in img_gallery])
#lra_train = np.array([lbp(img,8,2).flatten() for img in img_gallery])
# LRA Matrix
#project_m = np.hstack((np.eye(149),np.zeros((149,number*140))))
#W = np.dot(project_m,np.linalg.pinv(lra_train.T))
W = np.dot(np.eye(149),np.linalg.pinv(lra_train.T))
# Test Image
probe = np.loadtxt('probe.txt',dtype='string',delimiter=' ')
probe = pd.DataFrame(probe,columns=['path','ori_pose','ori_ill'])
#label = np.repeat(range(149)*19,6)
#label = np.repeat(range(149),6)
label = range(149)*19 #
pose = ['041', '050', '080', '130','140', '190']
light = ['00','01','02','03','04','05','06','08','09','10','11',
'12','13','14','15','16','17','18','19']
total = []
for ipose in pose:
count = 0
#probe_pose = probe[probe.ori_ill==ipose].values
probe_pose = probe[probe.ori_pose==ipose].values
for i in range(probe_pose.shape[0]):
name = '/home/pris/frontal_multipie_new2/'+probe_pose[i,0][3:]
img = cv2.imread(name,0)
feat = calHistogram(lbp(img,8,2),16,16)
#feat = lbp(img,8,2).flatten()
ilabel = np.dot(W,feat).argmax()
if(ilabel == label[i]):
count = count+1
print('Current Acc: %d / %d , %f' % (count,i,count/float(i)))
total.append(count/float(i))
def binFaces_noex(image_name):
faces = detectFaces(image_name)
image = cv2.imread(image_name)
if faces:
the_face = image[faces[1]:faces[3], faces[0]:faces[2]]
gray = cv2.cvtColor(the_face, cv2.COLOR_BGR2GRAY)
return lbp(gray, 8, 1)
else:
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
return lbp(gray, 8, 1)
def lbp_like(img, windows_num=4, P=8, R=1, lbp_type='uniform'):
LBP_TYPE = ('default', 'ror', 'uniform', 'var')
if lbp_type not in LBP_TYPE:
return None
H, W = img.shape
h_step = H / windows_num
w_step = W / windows_num
out_lst = []
for start_h in range(0, H - h_step + 1, h_step):
for start_w in range(0, W - w_step + 1, w_step):
end_h = start_h + h_step
end_w = start_w + w_step
rec_img = img[start_h:end_h, start_w:end_w]
rec_lbp = lbp(rec_img, P, R, lbp_type)
if lbp_type == 'uniform':
lst = [0] * (P + 2)
elif lbp_type in ['default', 'ror']:
lst = [0] * (math.pow(2, P))
for i in range(len(rec_lbp)):
for j in range(len(rec_lbp[0])):
lst[int(rec_lbp[i][j])] = lst[int(rec_lbp[i][j])] + 1
normal_lst = map(lambda x: round((float(x) / float(sum(lst))), 4),
lst)
out_lst = out_lst + normal_lst
return np.array(out_lst)
def get_all_faces(img):
a,faces = detect_faces(img)
faces_list = []
for face in faces:
the_face = img[face[1]:face[3], face[0]:face[2]]
faces_list.append(lbp(the_face,8,1))
return a,faces_list
def binFaces(image_name):
face = detectFaces(image_name)
image = cv2.imread(image_name)
if face:
the_face = image[face[1]:face[3], face[0]:face[2]]
gray = cv2.cvtColor(the_face, cv2.COLOR_BGR2GRAY)
return lbp(gray, 8, 1)
else:
return np.array([[None]])
def pattern(img, radius=3, points=8):
# Params
n_points = points * radius
img = normalize(img)
img1 = lbp(img, radius, n_points)
img1 = normalize(img1)
original_image = resize(img)
lbp_image = resize(img1)
stack = np.hstack([original_image, lbp_image])
return stack
def process_image(image, args=object):
if args.DES_TYPE == "HOG":
fd = hog(image, block_norm='L2', pixels_per_cell=args.PIXELS_PER_CELL)
elif args.DES_TYPE == "LBP":
fd = lbp(image, args.LBP_POINTS, args.LBP_RADIUS)
elif args.DES_TYPE == "HAAR":
fd = haar_like_feature(integral_image(image), 0, 0, 5, 5, 'type-3-x')
else:
raise KeyError("==> The Processing method does not exist!")
return fd
def extract_lbp_feature(file, # the string location of the image
radius=1, # the radius about which to look
npoints=8, # the number of points around the radius.
nbins=128, # for plotting the histogram
range_bins=(0, 255)): # the range for plotting the histogram
rgb = file
gry = rgb2gray(rgb)
feat = lbp(gry, R = radius, P = npoints)
feats, edges = np.histogram( feat, bins = nbins, range = range_bins)
return feat, edges
def classify(im, mask,cla="SVM"):
""" Classification of blobs
:im: Image with traffic signs
:mask: Mask after segmentation
:returns: List of bounding boxes
"""
# Training
bb_sol = []
label_im = label(mask >200)
props = regionprops(label_im)
if cla=="SVM":
for p in props:
coordinates = Rect(xmin=p.bbox[0], ymin=p.bbox[1], xmax=p.bbox[2], ymax=p.bbox[3])
signs = im[coordinates.xmin:coordinates.xmax, coordinates.ymin:coordinates.ymax, :]
signs_found = resize(signs, (32, 32))
io.imsave("/home/cesar/Desktop/datasetminin/gg.jpg", signs)
datasetlbp = lbp(rgb2gray(signs_found), 8, 3, method='uniform')
hist = np.histogram(datasetlbp, normed=True, bins=8, range=(0, 8))
input_predict = hist[0]
predict = clfSVM.predict([input_predict])
if predict[0] == 1:
bb_sol.append(coordinates)
return bb_sol
if cla=="NN":
for p in props:
coordinates = Rect(xmin=p.bbox[0], ymin=p.bbox[1], xmax=p.bbox[2], ymax=p.bbox[3])
signs = im[coordinates.xmin:coordinates.xmax, coordinates.ymin:coordinates.ymax, :]
signs_found = resize(signs, (32, 32))
datasetlbp = lbp(rgb2gray(signs_found), 8, 3, method='uniform')
hist = np.histogram(datasetlbp, normed=True, bins=8, range=(0, 8))
input_predict = hist[0]
predict = clfNN.predict([input_predict])
if predict[0] == 1:
bb_sol.append(coordinates)
return bb_sol
def lbpTexture (im, name, label, neighbors=2, radio=16):
'''
radio = 2
neighbors = 8 * radio
'''
lbp_image = lbp(im,P = neighbors, R = radio)
t = im.shape[0]
hist,bin = np.histogram(lbp_image,density=False,bins = 256) #compute the histogram
hist = np.float32(hist)
hist = hist/t
return hist,name,label
def LBP(numPoints, radius, image, eps=1e-7):
m_lbp = lbp(image, numPoints, radius, method="uniform")
(hist, _) = np.histogram(m_lbp.ravel(),
bins=np.arange(0, numPoints + 3),
range=(0, numPoints + 2))
# normalize the histogram
hist = hist.astype("float")
hist /= (hist.sum() + eps)
assert (hist.shape == (26, )), "LBP shape expected 26, got {}".format(
hist.shape)
return hist.ravel()
def lbp_classifier():
iset='ccbr'
number = 10
img_gallery, y_gallery = load_gallery(iset,1)
lra_train1 = np.array([calHistogram(lbp(img,8,2),24,20) for img in img_gallery])
lra_train2 = load_lra_train(iset, number, resize = 1)
lra_train2 = np.array([calHistogram(lbp(img,8,2),24,20) for img in lra_train2])
lra_train = np.vstack((lra_train1,lra_train2))
# LRA Matrix
project_m = np.hstack((np.eye(149),np.zeros((149,number*140))))
W = np.dot(project_m,np.linalg.pinv(lra_train.T))
#W = np.dot(np.eye(149),np.linalg.pinv(lra_train1.T))
# Test Image
probe = np.loadtxt('probe.txt',dtype='string',delimiter=' ')
probe = pd.DataFrame(probe,columns=['path','ori_pose','ori_ill'])
#label = np.repeat(range(149)*19,6)
#label = np.repeat(range(149),6)
label = range(149)*19 #
pose = ['041', '050', '080', '130','140', '190']
light = ['00','01','02','03','04','05','06','08','09','10','11',
'12','13','14','15','16','17','18','19']
total = []
for ipose in pose:
count = 0
#probe_pose = probe[probe.ori_pose==ipose].values
probe_pose = probe[probe.ori_pose==ipose].values
for i in range(probe_pose.shape[0]):
if(iset == 'ccbr'):
name = 'ccbr_probe/'+probe_pose[i,0][:-3]+'jpg'
else:
name = 'cpf_probe/'+probe_pose[i,0][:-3]+'bmp'
img = cv2.imread(name,0)
feat = calHistogram(lbp(img,8,2),24,20)
ilabel = np.dot(W,feat).argmax()
if(ilabel == label[i]):
count = count+1
print('Current Acc: %d / %d , %f' % (count,i,count/float(i)))
total.append(count/float(i))
def hdlbp(img, P=8, R=2, cell_size=4, fmt='default'):
"""
Parameters
----------
img : (N, M) array
Graylevel image.
P : int
Number of circularly symmetric neighbour set points (quantization of
the angular space).
R : float
Radius of circle (spatial resolution of the operator).
cell_size : int
block size of lbp cell
fmt : {'default', 'ror', 'uniform', 'var'}
Method to determine the pattern.
* 'default': original local binary pattern which is gray scale but not
rotation invariant.
* 'ror': extension of default implementation which is gray scale and
rotation invariant.
* 'uniform': improved rotation invariance with uniform patterns and
finer quantization of the angular space which is gray scale and
rotation invariant.
* 'nri_uniform': non rotation-invariant uniform patterns variant
which is only gray scale invariant [2].
* 'var': rotation invariant variance measures of the contrast of local
image texture which is rotation but not gray scale invariant.
Returns
-------
output : 1-D array
HDLBP feature.
References
----------
.. [1] Multiresolution Gray-Scale and Rotation Invariant Texture
Classification with Local Binary Patterns.
Timo Ojala, Matti Pietikainen, Topi Maenpaa.
http://www.rafbis.it/biplab15/images/stories/docenti/Danielriccio/\
Articoliriferimento/LBP.pdf, 2002.
.. [2] Face recognition with local binary patterns.
Timo Ahonen, Abdenour Hadid, Matti Pietikainen,
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.214.6851,
2004.
"""
lbpTrain = calHistogram(lbp(img, P, R), cell_size)
#lbpTrain_2 = np.array([calHistogram(lbp(img,8,2),19,16) for img in trainimg1])
#lbpTrain_3 = np.array([calHistogram(lbp(img,8,2),14,12) for img in trainimg1])
#lbpTrain = np.hstack((lbpTrain_1,lbpTrain_2,lbpTrain_3))
return lbpTrain
def lbp_histrogram( image ):
'''Process LBP Histogram from a picture of a fish.'''
lbpParams = (8, 2)
# The goal is to subdivide the picture in different ways (3 here) and to
# concatenate their histograms.
subdivs = [(3, 12)]#, (4, 16)]
# Here is the computation of one histogram (defined in Face Recognition with
# Local Binary Patterns).
# We shall first find n (the number of possible values of LBP) and m (the
# number of regions). Note that n += 1 because we want a value that represent
# non-uniformity.
subdiv = subdivs[0]
n = n_for_2_uniform_lbp(lbpParams) + 1
m = subdiv[0] * subdiv[1]
# Then, we have an histogram that consists of the concatenation of m
# histograms, each one of size n. It means, for one region we keep
# the number of pixels that represent a label of LBP.
# Jehan, note that I preallocated the table ! In python !
lbpHist = zeros((m, n))
lbpImage = lbp(image, lbpParams[0], lbpParams[1]) # …, method = 'uniform')
labelMap = lut(lbpParams[0])
# Effective creation of the histogram.
region = 0
for tileBounds in TiledIterator(lbpImage, subdiv):
tile = image[tileBounds]
size = shape(tile)
area = size[0] * size[1]
for row in range(size[0]):
for col in range(size[1]):
# Get the LBP at (row, col)
label = tile[row, col]
# And count it
if (uniform_pattern(label, lbpParams[0], 2)):
lbpHist[region, labelMap[label]] += 1
else:
lbpHist[region, n-1] += 1
# Normalise
lbpHist[region] = lbpHist[region] / area
region += 1
#lbpHist = normalise_lbphistogram(lbpHist)
return lbpHist
def gethistHSV(img):
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
if len(faces) > 0:
histogram = np.array([])
x, y, w, h = faces[0]
crop_face = gray[y:y + w, x:x + h]
crop_face = cv2.resize(crop_face, (64, 64))
radius = 2
n_points = 16
# for i in range(crop_face.shape[2]):
l = lbp(crop_face, n_points, radius, method='uniform')
histogram = np.append(histogram, l.ravel())
return histogram, faces
def process_image(self, image):
'''
This function is used to extract features from input image
according to the config
:param image: input image
:return: The features extracted from input image
'''
if self.config.DES_TYPE == "HOG":
fd = hog(image,
block_norm='L2',
pixels_per_cell=self.config.PIXELS_PER_CELL)
elif self.config.DES_TYPE == "LBP":
fd = lbp(image, self.config.LBP_POINTS, self.config.LBP_RADIUS)
elif self.config.DES_TYPE == "HAAR":
fd = haar_like_feature(integral_image(image), 0, 0, 5, 5,
'type-3-x')
else:
raise KeyError("==> The Processing method does not exist!")
return fd
def _process(self, path):
"""
Performing some operations, common for all the options
"""
if not os.path.isfile(path):
#change that!
sys.exit('File doesnt exist.')
#grayscale image
img = cv.imread(path, cv.IMREAD_GRAYSCALE)
#lbp representation
lbp_img = lbp(img, cfg.params['P'], cfg.params['R'],
cfg.params['LBP_METHOD'])
lbp_img = lbp_img.astype(np.uint8)
#histogram representation
hist = histogram.spatial(lbp_img, cfg.params['NX'], cfg.params['NY'],
cfg.params['NPATTERNS'],
cfg.params['OVERLAPX'],
cfg.params['OVERLAPY'])
return (lbp_img, hist)
def extract_lbp_feature(
file, # the string location of the image
radius=1, # the radius about which to look
npoints=8, # the number of points around the radius.
nbins=128, # for plotting the histogram
range_bins=(0, 255)): # the range for plotting the histogram
# Read in the file. Because this is different to the template.py you will have to
# Import all your libraries that you want to use again.
rgb = imread(file)
gry = rgb2gray(rgb)
# Convert it to greyscale.
# Now you need to import local_binary_pattern from skimage.features in the import area.
# In much the same way that HOG does lbp has some basic parameters.
# R is the radius around a central pixels that it will extend. In this case 1 means
# that it will extend out from the center pixel 1 pixels (or there abouts), as the number
# increases we scan a larger area.
# P - number of points, to look at on the radius, for a radius of 1 it makes sense to look
# at 8 pixels, why do you think?
# Using this information we can use the local_binary_pattern in the following way:
# features = local_binary_pattern( input image, R=radius, P=npoints )
# When you are finished print the features shape.
feat = lbp(gry, R=radius, P=npoints)
# Let's go back to template.py and run this function.
# So you have run it, what do you notice? The output is 140*140 which was the size of
# our input image. So each pixel has a value associated with it! These values for the
# standard lbp range from 0->255 based on a combination of pixels. For more information
# on exactly how this is computed see: https://towardsdatascience.com/face-recognition-how-lbph-works-90ec258c3d6b
# For here though, we are just going to assume that for each pixel in the image we have
# a value on the range [0,255]. Next we need to create a feature vector based on these
# values. We will use np.histogram to classify our values.
# np.histogram takes as input the features you want to bin, the number of bins and the range
# of the input.
# By default we will classify the features into 128 bins on the range 0-255.
feats, edges = np.histogram(feat, bins=nbins, range=range_bins)
# now we need to return feats and edges and then go back to the template.py
return feat, edges
def LBP(image, points=8, radius=1):
'''
Uniform Local Binary Patterns algorithm
Input image with shape (height, width, channels)
Output features with length * number of channels
'''
# calculate pattern length
length = points**2 - abs(points - 3)
# lbp per channel in image
histogram = np.empty(0, dtype=np.int)
for i in range(image.shape[2]):
channel = image[:, :, i]
pattern = lbp(channel, points, radius, method='nri_uniform')
pattern = pattern.astype(np.int).ravel()
pattern = np.bincount(pattern)
if len(pattern) < length:
pattern = np.concatenate((pattern, np.zeros(59 - len(pattern))))
histogram = np.concatenate((histogram, pattern))
# normalize the histogram and return it
features = (histogram - np.mean(histogram)) / np.std(histogram)
return features
def base_lbp(image, P, R, method, block,):
check_nD(image, 2)
image = np.ascontiguousarray(image, dtype=np.double)
output = lbp(image, P, R, method) # original
if method == DEFAULT:
bins = 2**P
elif method == UNIFORM:
bins = P + 2
elif method == NRI_UNIFORM:
bins = P * (P - 1) + 3
elif method == ROR:
bins = bins_ROR[str(P)]
else: # method == VAR
bins = None
return histogram(output, bins, block)
image = cv2.imread(
"/home/efforia/PycharmProjects/OpenCVProject/images/grant.jpg",
cv2.IMREAD_GRAYSCALE)
cv2.imshow("image", image)
target_flag = False
target_lbp_hist = None
finish_sliding = False
radius = 2
n_points = radius * 8
roi = None
ROI_selector = RectSelector("image", onmouse)
lbp_image = lbp(image, n_points, radius, 'uniform')
while True:
if not ROI_selector.dragging:
cv2.imshow("image", image)
if roi is not None:
cv2.imshow("roi", roi)
if target_flag:
lbp_count = 0
attempt = 0
stepSize = 32
clone = image.copy()
target_flag = False
finish_sliding = False
cv2.imshow("target roi", roi)
def cell_lbp_hist(self, img, trans=True):
if trans == True:
img = img.transpose()
winSize = self.winSize
blockSize = self.blockSize
blockStride = self.blockStride
cellSize = self.cellSize
winStride = self.winStride
radius = self.radius
npoints = self.npoints
from skimage.feature import local_binary_pattern as lbp
import numpy as np
METHOD = 'uniform'
flag_1 = (winSize[0] % blockSize[0] == 0
and winSize[1] % blockSize[1] == 0
and blockSize[0] % cellSize[0] == 0
and blockSize[0] % cellSize[0] == 0)
flag_2 = (img.shape[0] >= 64 and img.shape[1] >= 128)
if flag_2 == False:
print('Size error')
print img.shape
return
lbpim = lbp(img, npoints, radius, METHOD)
up_left = (0, 0)
b_left = (0, winSize[1])
up_right = (winSize[0], 0)
b_right = winSize
win_corners = (up_left, up_right, b_right, b_left)
hist = np.array([])
while win_corners[2][1] <= lbpim.shape[1]:
while win_corners[2][0] <= lbpim.shape[0]:
win = lbpim[win_corners[0][0]:win_corners[1][0],
win_corners[0][1]:win_corners[3][1]]
bl_corners = ((0, 0), (blockSize[0], 0), blockSize,
(0, blockSize[1]))
while bl_corners[2][1] <= win.shape[1]:
while bl_corners[2][0] <= win.shape[0]:
block = win[bl_corners[0][0]:bl_corners[1][0],
bl_corners[0][1]:bl_corners[3][1]]
cell_corners = ((0, 0), (cellSize[0], 0), cellSize,
(0, cellSize[1]))
while cell_corners[2][1] <= block.shape[1]:
while cell_corners[2][0] <= block.shape[0]:
cell = block[
cell_corners[0][0]:cell_corners[1][0],
cell_corners[0][1]:cell_corners[3][1]]
local_hist = np.zeros(npoints + 2)
for line in cell:
for i in line:
index = int(i)
local_hist[index] += 1
hist = np.concatenate((hist, local_hist))
cell_corners = stride(cell_corners, cellSize,
'right')
cell_corners = stride(cell_corners, cellSize,
'down')
cell_corners = left_start(cell_corners, cellSize)
bl_corners = stride(bl_corners, blockStride, 'right')
bl_corners = stride(bl_corners, blockStride, 'down')
bl_corners = left_start(bl_corners, blockSize)
win_corners = stride(win_corners, winStride, 'right')
win_corners = stride(win_corners, winStride, 'down')
win_corners = left_start(win_corners, winSize)
return hist.reshape((hist.shape[0], 1))
plt.title('IMG' + str(index[i]))
plt.show()
#Using the Local Binary Pattern (LBP) recognizing features
b = [i for i in range(0, 55)]
b.append(255)
lbp_imgs = []
lbp_hists = []
for im in imgs:
im = cv2.cvtColor(
im, cv2.COLOR_BGR2GRAY
) #needed to be added because otherwise expected im should be 2d array with rgb
aux = lbp(im, 8, 28, method='default')
lbp_imgs.append(aux)
aux2, _ = np.histogram(aux, bins=b)
lbp_hists.append(aux2)
lbp_hists = np.asarray(lbp_hists)
#some of the histograms are to jsut view it
plt.figure(figsize=(12, 2))
for i, hist in enumerate(lbp_hists[index]):
plt.subplot(1, 5, i + 1)
plt.bar(b[:len(b) - 2], hist[:len(hist) - 1])
plt.xticks(())
plt.yticks(())
from time import time
from matplotlib import pyplot as plt
from skimage.feature import local_binary_pattern as lbp
folder_awal = 'KELAS_DATA/'
folder_tujuan = 'KELAS_DATA_lbp/'
ls = os.listdir(folder_awal)
if folder_tujuan not in ls:
os.mkdir(folder_tujuan)
R = 3 #radius
P = 8 * R #himpunan titik ketetanggaan
total = 0
for i in range(len(ls)):
now = time()
filename = ls[i]
filepath = folder_awal + filename
img = cv2.imread(filepath, 1)
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img_lbp = lbp(img_gray, P, R, method='default')
plt.imsave(folder_tujuan + 'lbp_' + filename, img_lbp, cmap='gray')
print("{}/{} done in {:.2f}s. ({}%)".format(i + 1, len(ls),\
time() - now, 100 * float(i + 1) / (len(ls))))
total += (time() - now)
print('Total {:.2f}s.'.format(total))
def handle_LBP(gray_img, sample_coord, block_size=(20, 60), similar_condi=0.85):
"""
function:
handle_LBP(gray_img, sample_coord[, block_size=(20, 60)[, similar_condi=0.85]]):
計算原始圖像和 sample 的 LBP 相似度
parameter:
gray_img: 調整大小後的灰階圖像
sample_coord: 所有 sample 位於原始圖像的位置(左上角座標)
block_size: 和 handle_sample 的 block_size 相同
similar_condi: 相似度的門檻值, 默認 0.85, 範圍[0, 1), float
method:
1. 計算 sample LBP 值以及直方圖
2. 相似度比較去除最不相似的 sample
(採取逐一比較的方式, 去除相似度最低的, 其餘的都當成 markers)
(相似度最低的判斷為 當前相似個數 - 最小相似個數 > 全距 // 2)
3. 天空全部都標成 marker(最上面一行)
4. 侵蝕一次
return:
markers: 二值化的圖像, 用來當成 watershed 的 markers
"""
markers = np.zeros(gray_img.shape, np.uint8)
width, height = block_size
# 儲存 每張 LBP 值的 直方圖列表
hist_list = list()
for coord in sample_coord:
y, x = coord
target = gray_img[y:y + height, x:x+width]
# 1. 計算 LBP 值(為了要使用 cv2.calcHist 函數, 要把圖像的資料類型轉成 np.uint8)
lbp_img = lbp(target, 8, 1).astype(np.uint8)
hist = cv2.calcHist([lbp_img], [0], None, [256], [0, 256])
hist_list.append(hist)
# 畫出所有 sample 的位置
cv2.rectangle(gray_img, (x, y), (x + width, y + height), (255, 255, 255), 5)
# cv2.imshow('sample region', gray_img)
# print('hist 個數: ', len(hist_list))
# 2.
# 存放相似度結果的列表
similar_list = list()
for i in range(0, len(hist_list)):
cnt = -1 # 計算相似個數(採逐一比較, 自己和自己比一定相似, 所以要減一)
for j in range(0, len(hist_list)):
sim = cv2.compareHist(hist_list[i], hist_list[j], cv2.HISTCMP_CORREL)
if sim >= similar_condi:
cnt += 1
similar_list.append(cnt)
# print("similar list: ", similar_list, "個數: ", len(similar_list))
# 當前的個數 - 最小相似個數 <= sample 數量 // 2
# markers_coord = list() # 儲存最後被當成 markers 的座標
for index, coord in enumerate(sample_coord):
y, x = coord
if similar_list[index] - min(similar_list) <= (max(similar_list) - min(similar_list)) // 2:
# markers_coord.append((y, x))
markers[y:y+height, x:x+width] = 255
cv2.rectangle(gray_img, (x, y), (x + width, y + height), (0, 0, 0), 2)
# 加上天空的座標
for x in range(0, gray_img.shape[1], width):
# markers_coord.append((0, x))
markers[10:10+height, x+width:x-width] = 255
# cv2.imshow('sample region', gray_img)
# print(len(markers_coord))
# 3.
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
markers = cv2.erode(markers, kernel, iterations=1)
# cv2.imshow('markers', markers)
return markers
parser.add_argument('-i', '--insert', action='store_true')
parser.add_argument('path', type=str)
args = parser.parse_args()
path = args.path
filename = path.strip().split('/')[-1]
if not os.path.isfile(path):
sys.exit('File doesnt exist.')
"""
Performing some operations, common for all
the options
"""
#greyscale image
img = cv.imread(path, cv.IMREAD_GRAYSCALE)
#lbp representation
lbp_img = lbp(img, cfg.params['P'], cfg.params['R'],
cfg.params['LBP_METHOD'])
lbp_img = lbp_image.astype(np.uint8)
#histogram representation
hist = histogram.spatial(lbp_img, cfg.params['NX'], cfg.params['NY'],
cfg.params['NPATTERNS'], cfg.params['OVERLAPX'],
cfg.params['OVERLAPY'])
#Verify if the argument photo is or not
#a valid one, i.e, corresponds to dog nose.
if args.verify:
#loading svm object
tgt = open(cfg.params['VAULT'] + 'SVM', 'rb')
clf = pickle.load(tgt)
tgt.close()
#predict
result = clf.predict([hist])
def main(folders):
"""Pretty much self-explanatory thanks to python: sets up servos and then reads images from picamera array and does stuff based on params"""
servo = Servo(12,23,60/320, 45/240,320,240,90,90)
global recognizer
recognizer = cv2.createLBPHFaceRecognizer()
trainAll(folders)
if showImage:
cv2.namedWindow("The Luca Bazooka", cv2.cv.CV_WINDOW_AUTOSIZE)
camera=PiCamera()
camera.resolution=resolution
camera.framerate=framerate
rawCapture=PiRGBArray(camera,size=size)
frameNumber = 0
if outputToFile:
video_writer=imageio.get_writer('~/The-Luca-Bazooka/'+filename,fps=24)
for nonprocessed in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
frameNumber += 1
if debug:
print('VIDEO CAPTURE GOING')
frame=nonprocessed.array
if rotate:
frame=ndimage.rotate(frame,270)
if debug:
#print(frame)
pass
faces = extractFace(frame)
for i in faces:
(x, y, w, h) = i
predicted = predict(
cv2.cvtColor(crop(frame, i), cv2.COLOR_RGB2GRAY))
if showImage:
cv2.imshow(
'Detected Face', cv2.cvtColor(crop(frame, i), cv2.COLOR_RGB2GRAY))
if visualizeLBP:
cv2.imshow('LBP Histogram',lbp(cv2.cvtColor(crop(frame,i),cv2.COLOR_RGB2GRAY)
,1,15))
if debugStuff:
print(predicted)
if predicted[1] <= confidenceLevel and (showImage or outputImage):
print 'FOUND LUCA FACE'
cv2.rectangle(frame, (x, y), (x+w, y+h), (227, 45, 45), 2)
servo.update(x+w/2, y+h/2)
if debug:
print('Updating servo with coords:')
print(x+w/2-160,y+h/2-120)
charactersToCutOff=len('/home/pi')+len("/The-Luca-Bazooka/training/")
cv2.putText(
frame, folders[predicted[0]][charactersToCutOff:-1], (x, y), cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 255, 255))
if predicted[1] <= confidenceLevel and not (showImage or outputImage):
servo.update(x+w/2-160, y+h/2-120)
if debug:
print 'UPDATING SERVO WITH COORDS:'
print (x+w/2,y+h/2)
print 'FOUND LUCA FACE'
print 'CONFIDENCE START'
print (predicted[1])
print 'CONFIDENCE END'
else:
if debug:
print 'FOUND NON-LUCA FACE'
print (x,y,x+w,y+h)
if showImage or outputImage:
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 191, 255), 2)
if outputImage:
cv2.imwrite(outputImagePath+str(frameNumber)+'.jpg',frame)
if showImage:
cv2.imshow("The Luca Bazooka", frame)
if outputToFile==True:
video_writer.append_data(frame)
rawCapture.truncate(0)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if outputToFile==True:
video_writer.close()
vidcap.release()
cv2.destroyAllWindows()
while True:
if not ROI_selector.dragging:
cv2.imshow("image", image)
if roi is not None:
cv2.imshow("roi", roi)
hsv_roi = cv2.cvtColor(roi.copy(), cv2.COLOR_BGR2HSV)
gray_roi = cv2.cvtColor(roi.copy(), cv2.COLOR_BGR2GRAY)
if target_flag:
target_flag = False
cv2.imshow("target roi", roi)
target_hist = cv2.calcHist([hsv_roi], [0], None, [24],
[0, 180])
show_hist(target_hist, "target")
target_lbp = lbp(gray_roi, n_points, radius, 'uniform')
target_lbp = np.asarray(target_lbp, dtype=np.uint8)
n_bins = int(target_lbp.max() + 1)
target_lbp_hist = cv2.calcHist([target_lbp], [0], None,
[n_bins], [0, n_bins])
# cv2.normalize(target_lbp_hist, target_lbp_hist, 0, 1, cv2.NORM_MINMAX)
# target_lbp_hist, _ = np.histogram(target_lbp, bins=n_bins, range=(0, n_bins), normed=True)
# target_lbp_hist = np.asarray(target_lbp_hist, dtype=np.float32)
elif candidate_flag:
candidate_flag = False
candidate_hist = cv2.calcHist([hsv_roi], [0], None, [24],
[0, 180])
show_hist(candidate_hist, "candidate")
candidate_lbp = lbp(gray_roi, n_points, radius, 'uniform')
candidate_lbp = np.asarray(candidate_lbp, dtype=np.uint8)
