def race_det(img_path):
result_names = []
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, npy)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 1000
image_size = 182
input_image_size = 160
HumanNames = ['Asian', 'Black', 'Indian', 'White']
#HumanNames.sort()
print('Loading embedding extraction model')
facenet.load_model(modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
classifier_filename_exp = os.path.expanduser(classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
c = 0
print('Start Recognition!')
prevTime = 0
i = 0
ratio = 0.0
name = os.path.basename(img_path)
frame = cv2.imread(img_path, 0)
frame = cv2.resize(frame, (0, 0), fx=0.5,
fy=0.5) #resize frame (optional)
curTime = time.time() + 1 # calc fps
timeF = frame_interval
if (c % timeF == 0):
find_results = []
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
frame, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
#print('Face Detected: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(frame.shape)[0:2]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][2] >= len(
frame[0]) or bb[i][3] >= len(frame):
print('face is too close')
return 'Unable to align, face too close'
continue
cropped.append(frame[bb[i][1]:bb[i][3],
bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(
misc.imresize(cropped[i], (image_size, image_size),
interp='bilinear'))
scaled[i] = cv2.resize(
scaled[i], (input_image_size, input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(
-1, input_image_size, input_image_size, 3))
feed_dict = {
images_placeholder: scaled_reshape[i],
phase_train_placeholder: False
}
emb_array[0, :] = sess.run(embeddings,
feed_dict=feed_dict)
predictions = model.predict_proba(emb_array)
#print(predictions)
best_class_indices = np.argmax(predictions, axis=1)
#if HumanNames[best_class_indices[0]]==folder:
#pred_len+=1
# print(best_class_indices)
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
#print(best_class_probabilities)
cv2.rectangle(frame, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]), (0, 255, 0),
2) #boxing face
#plot result idx under box
text_x = bb[i][0]
text_y = bb[i][3] + 20
#print('Result Indices: ', best_class_indices[0])
#print(HumanNames)
for H_i in HumanNames:
# print(H_i)
if HumanNames[best_class_indices[0]] == H_i:
result_names.append(
HumanNames[best_class_indices[0]])
#cv2.putText(frame, result_names, (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL,
#1, (0, 0, 255), thickness=1, lineType=2)
return result_names
else:
return ['No face detected']
def collect_data(self):
output_dir = os.path.expanduser(self.output_datadir)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
dataset = facenet.get_dataset(self.input_datadir)
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)
sess = tf.Session(config=tf.ConfigProto(
gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, '')
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
image_size = 182
# Add a random key to the filename to allow alignment using multiple processes
random_key = np.random.randint(0, high=99999)
bounding_boxes_filename = os.path.join(
output_dir, 'bounding_boxes_%05d.txt' % random_key)
with open(bounding_boxes_filename, "w") as text_file:
nrof_images_total = 0
nrof_successfully_aligned = 0
for cls in dataset:
output_class_dir = os.path.join(output_dir, cls.name)
if not os.path.exists(output_class_dir):
os.makedirs(output_class_dir)
for image_path in cls.image_paths:
nrof_images_total += 1
filename = os.path.splitext(
os.path.split(image_path)[1])[0]
output_filename = os.path.join(output_class_dir,
filename + '.png')
print("Image: %s" % image_path)
if not os.path.exists(output_filename):
try:
img = misc.imread(image_path)
except (IOError, ValueError, IndexError) as e:
errorMessage = '{}: {}'.format(image_path, e)
print(errorMessage)
else:
if img.ndim < 2:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
continue
if img.ndim == 2:
img = facenet.to_rgb(img)
print('to_rgb data dimension: ', img.ndim)
img = img[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
img, minsize, pnet, rnet, onet, threshold,
factor)
nrof_faces = bounding_boxes.shape[0]
print('No of Detected Face: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(img.shape)[0:2]
if nrof_faces > 1:
bounding_box_size = (
det[:, 2] - det[:, 0]) * (det[:, 3] -
det[:, 1])
img_center = img_size / 2
offsets = np.vstack([
(det[:, 0] + det[:, 2]) / 2 -
img_center[1],
(det[:, 1] + det[:, 3]) / 2 -
img_center[0]
])
offset_dist_squared = np.sum(
np.power(offsets, 2.0), 0)
index = np.argmax(
bounding_box_size -
offset_dist_squared * 2.0
) # some extra weight on the centering
det = det[index, :]
det = np.squeeze(det)
bb_temp = np.zeros(4, dtype=np.int32)
bb_temp[0] = det[0]
bb_temp[1] = det[1]
bb_temp[2] = det[2]
bb_temp[3] = det[3]
cropped_temp = img[bb_temp[1]:bb_temp[3],
bb_temp[0]:bb_temp[2], :]
scaled_temp = misc.imresize(
cropped_temp, (image_size, image_size),
interp='bilinear')
nrof_successfully_aligned += 1
misc.imsave(output_filename, scaled_temp)
text_file.write(
'%s %d %d %d %d\n' %
(output_filename, bb_temp[0], bb_temp[1],
bb_temp[2], bb_temp[3]))
else:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
return (nrof_images_total, nrof_successfully_aligned)
def get_image_item(self, img_path):
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(
gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, npy)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 1000
image_size = 182
input_image_size = 160
probval = ""
kindval = ""
HumanNames = os.listdir(train_img)
HumanNames.sort()
print('Loading feature extraction model')
facenet.load_model(modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
#print(embedding_size)
classifier_filename_exp = os.path.expanduser(
classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
# video_capture = cv2.VideoCapture("akshay_mov.mp4")
c = 0
print('Start Recognition!')
prevTime = 0
# ret, frame = video_capture.read()
frame = cv2.imread(img_path, 0)
frame = cv2.resize(frame, (0, 0), fx=0.5,
fy=0.5) #resize frame (optional)
curTime = time.time() + 1 # calc fps
timeF = frame_interval
if (c % timeF == 0):
find_results = []
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
frame, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
print('Face Detected: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(frame.shape)[0:2]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][
2] >= len(
frame[0]) or bb[i][3] >= len(frame):
print('face is too close')
#items.append(dict(prob='', kind='face is too close'))
item = dict(prob='', kind='face is too close')
continue
cropped.append(frame[bb[i][1]:bb[i][3],
bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(
misc.imresize(cropped[i],
(image_size, image_size),
interp='bilinear'))
scaled[i] = cv2.resize(
scaled[i],
(input_image_size, input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(
-1, input_image_size, input_image_size, 3))
feed_dict = {
images_placeholder: scaled_reshape[i],
phase_train_placeholder: False
}
emb_array[0, :] = sess.run(embeddings,
feed_dict=feed_dict)
predictions = model.predict_proba(emb_array)
print(predictions)
best_class_indices = np.argmax(predictions, axis=1)
# print(best_class_indices)
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
print(best_class_probabilities)
#cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0), 2) #boxing face
#plot result idx under box
text_x = bb[i][0]
text_y = bb[i][3] + 20
print('Result Indices: ', best_class_indices[0])
#best_class_indices[0]=3
print(HumanNames)
for H_i in HumanNames:
#print(HumanNames[best_class_indices[0]])
if HumanNames[best_class_indices[0]] == H_i:
result_names = HumanNames[
best_class_indices[0]]
print(result_names)
if best_class_probabilities > 0.5:
probval += str(
best_class_probabilities) + ","
kindval += result_names + ","
#items.append(dict(prob=str(best_class_probabilities), kind=result_names))
#cv2.putText(frame, result_names, (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), thickness=1, lineType=2)
if probval != "":
item = dict(prob=probval.rstrip(','),
kind=kindval.rstrip(','))
else:
item = dict(prob='', kind='Unable to find face')
else:
item = dict(prob='', kind='No face is avilable')
print('Unable to align')
#cv2.imshow('Image', frame)
#cv2.waitKey(0)
#if cv2.waitKey(1000000) & 0xFF == ord('q'):
#sys.exit("Thanks")
#cv2.destroyAllWindows()
#pred = self.predict_images([img_path])[0]
#prob, kind = self.get_prob_and_kind(pred)
#item = dict(prob=prob, kind=kind)
return item
def recognize(filename="img.jpg"):
image_path = TEST_FOLDER + filename
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, npy)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
frame_interval = 3
image_size = 182
input_image_size = 160
HumanNames = os.listdir(TRAIN_FOLDER)
HumanNames.sort()
print('Loading feature extraction model')
facenet.load_model(MODEL_DIR)
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
classifier_filename_exp = os.path.expanduser(CLASSIFIER)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
c = 0
print('Start Recognition!')
frame = cv2.imread(image_path, 0)
frame = cv2.resize(frame, (0, 0), fx=0.5, fy=0.5) # resize frame (optional)
timeF = frame_interval
if (c % timeF == 0):
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(frame, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
print('Face Detected: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][2] >= len(frame[0]) or bb[i][3] >= len(frame):
print('face is too close')
continue
cropped.append(frame[bb[i][1]:bb[i][3], bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(misc.imresize(cropped[i], (image_size, image_size), interp='bilinear'))
scaled[i] = cv2.resize(scaled[i], (input_image_size, input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(-1, input_image_size, input_image_size, 3))
feed_dict = {images_placeholder: scaled_reshape[i], phase_train_placeholder: False}
emb_array[0, :] = sess.run(embeddings, feed_dict=feed_dict)
# print("emb_array",emb_array)
predictions = model.predict_proba(emb_array)
print("Predictions ", predictions)
best_class_indices = np.argmax(predictions, axis=1)
best_class_probabilities = predictions[np.arange(len(best_class_indices)), best_class_indices]
print("Best Predictions ", best_class_probabilities)
if best_class_probabilities[0] > 0.3:
print('Result Indices: ', best_class_indices[0])
print(HumanNames)
for H_i in HumanNames:
# print(H_i)
if HumanNames[best_class_indices[0]] == H_i:
result_names = HumanNames[best_class_indices[0]]
print("Face Recognized: ", result_names)
return str(result_names)
else:
print('Not Recognized')
return False
else:
print('Unable to align')
return False
return False
# ret, frame = video_capture.read()
frame = cv2.imread(img_path, 0)
frame = cv2.resize(frame, (0, 0), fx=0.5,
fy=0.5) #resize frame (optional)
curTime = time.time() + 1 # calc fps
timeF = frame_interval
if (c % timeF == 0):
find_results = []
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
frame, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
print('Face Detected: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(frame.shape)[0:2]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
def deti(input_filepath):
import pyrebase
config = {
"apiKey": "apiKey",
"authDomain": "projectId.firebaseapp.com",
"databaseURL": "https://databaseName.firebaseio.com",
"storageBucket": "projectId.appspot.com"
}
firebase = pyrebase.initialize_app(config)
auth = firebase.auth()
#authenticate a user
user = auth.sign_in_with_email_and_password("*****@*****.**", "123456")
user['idToken']
db = firebase.database()
img_path = input_filepath
modeldir = ''
classifier_filename = './class/classifier.pkl'
npy = ''
train_img = "./train_img"
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, npy)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 10000
image_size = 182
input_image_size = 160
HumanNames = os.listdir(train_img)
HumanNames.sort()
now = datetime.datetime.now()
print("printing to firebase")
for a in range(1, len(HumanNames)):
student = {HumanNames[a]: "Absent"}
db.child("Attendance").child(now.year).child(now.month).child(
now.day).child(now.hour).update(student, user['idToken'])
print('Loading feature extraction model')
facenet.load_model(modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
classifier_filename_exp = os.path.expanduser(classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
# video_capture = cv2.VideoCapture("akshay_mov.mp4")
c = 0
print('Start Recognition!')
prevTime = 0
# ret, frame = video_capture.read()
frame = cv2.imread(img_path, 0)
frame = cv2.resize(frame, (0, 0), fx=0.5,
fy=0.5) #resize frame (optional)
curTime = time.time() + 1 # calc fps
timeF = frame_interval
if (c % timeF == 0):
find_results = []
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
frame, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
print('Face Detected: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(frame.shape)[0:2]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][2] >= len(
frame[0]) or bb[i][3] >= len(frame):
print('face is too close')
continue
cropped.append(frame[bb[i][1]:bb[i][3],
bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(
misc.imresize(cropped[i], (image_size, image_size),
interp='bilinear'))
scaled[i] = cv2.resize(
scaled[i], (input_image_size, input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(
-1, input_image_size, input_image_size, 3))
feed_dict = {
images_placeholder: scaled_reshape[i],
phase_train_placeholder: False
}
emb_array[0, :] = sess.run(embeddings,
feed_dict=feed_dict)
predictions = model.predict_proba(emb_array)
print(predictions)
best_class_indices = np.argmax(predictions, axis=1)
# print(best_class_indices)
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
print(best_class_probabilities)
cv2.rectangle(frame, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]), (0, 255, 0),
2) #boxing face
#plot result idx under box
text_x = bb[i][0]
text_y = bb[i][3] + 20
print('Result Indices: ', best_class_indices[0])
print(HumanNames)
now = datetime.datetime.now()
print("printing to firebase")
student = {
HumanNames[best_class_indices[0]]: "Present"
}
db.child("Attendance").child(now.year).child(
now.month).child(now.day).child(now.hour).update(
student, user['idToken'])
print(student)
f = open("demofile.txt", "w")
f.write(HumanNames[best_class_indices[0]])
f.close()
for H_i in HumanNames:
# print(H_i)
if HumanNames[best_class_indices[0]] == H_i:
result_names = HumanNames[
best_class_indices[0]]
cv2.putText(frame,
result_names, (text_x, text_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (0, 0, 255),
thickness=1,
lineType=2)
else:
print('Unable to align')
cv2.imshow('Image', frame)
if cv2.waitKey(1000000) & 0xFF == ord('q'):
sys.exit("Thanks")
cv2.destroyAllWindows()
sess.close()
def recognizer(video_path,
pretrain_model='./models/20180408-102900',
classifier='./class/classifier.pkl',
npy_dir='./packages',
train_img_dir='./datasets'):
with tf.Graph().as_default():
#gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
gpu_options = tf.GPUOptions(allow_growth=True)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, npy_dir)
img_options = {
'minsize': 20,
'threshold': [0.6, 0.7, 0.7],
'factor': 0.709,
'margin': 44,
'frame_interval': 3,
'batch_size': 100,
'image_size': 182,
'input_image_size': 160
}
HumanNames = os.listdir(train_img_dir)
HumanNames.sort()
print('Loading model...')
facenet.load_model(pretrain_model)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
'input:0')
embeddings = tf.get_default_graph().get_tensor_by_name(
'embeddings:0')
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name('phase_train:0')
embedding_size = embeddings.get_shape()[1]
classifier_exp = os.path.expanduser(classifier)
with open(classifier_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
c = 0
print('Facial Recognition Starting...')
#win = dlib.image_window()
cap = cv2.VideoCapture(video_path)
while True:
ret, frame = cap.read()
frame = cv2.resize(frame, (0, 0), fx=0.7, fy=0.7)
#frame = dlib.load_rgb_image(img)
#frame = dlib.resize_image(img, 0.5, 0.5)
timeF = img_options['frame_interval']
if (c % timeF == 0):
#find_results = []
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
frame, img_options['minsize'], pnet, rnet, onet,
img_options['threshold'], img_options['factor'])
nrof_faces = bounding_boxes.shape[0]
print('Face Detected: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_options['img_size'] = np.asarray(frame.shape)[0:2]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][
2] >= len(
frame[0]) or bb[i][3] >= len(frame):
print('face is too close')
continue
cropped.append(frame[bb[i][1]:bb[i][3],
bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(
misc.imresize(cropped[i],
(img_options['image_size'],
img_options['image_size']),
interp='bilinear'))
scaled[i] = cv2.resize(
scaled[i], (img_options['input_image_size'],
img_options['input_image_size']),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(
-1, img_options['input_image_size'],
img_options['input_image_size'], 3))
feed_dict = {
images_placeholder: scaled_reshape[i],
phase_train_placeholder: False
}
emb_array[0, :] = sess.run(embeddings,
feed_dict=feed_dict)
predictions = model.predict_proba(emb_array)
print(predictions)
best_class_indices = np.argmax(predictions, axis=1)
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
#print(best_class_probabilities)
print('Accuracy: ', best_class_probabilities)
cv2.rectangle(frame, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]), (0, 255, 255),
1)
if best_class_probabilities > 0.25:
text_x = bb[i][0]
text_y = bb[i][1] - 10
print('Result Indices: ',
best_class_indices[0])
for H_i in HumanNames:
if HumanNames[
best_class_indices[0]] == H_i:
predict_names = HumanNames[
best_class_indices[0]]
cv2.putText(
frame,
predict_names, (text_x, text_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (0, 0, 255),
thickness=1,
lineType=2)
else:
text_x = bb[i][0]
text_y = bb[i][1] - 10
print('Result Indices: ',
best_class_indices[0])
cv2.putText(frame,
'Unknown', (text_x, text_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (0, 0, 255),
thickness=1,
lineType=2)
else:
print('Unable to find face')
if ret:
cv2.imshow('Facial Recognition', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
print('Ending...')
break
#sys.exit('Ending...')
cap.release()
cv2.destroyAllWindows()
def get_frame(self):
modeldir = '/Users/manohar/Downloads/RT-face-recognition/model/20180402-114759.pb'
classifier_filename = './class/classifier.pkl'
npy=''
api_url_base = 'https://hackathon-faceapp.herokuapp.com/recognize'
headers = {'cache-control': 'no-cache'}
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, npy)
# Load the model
facenet.load_model(modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
classifier_filename_exp = os.path.expanduser(classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
image_size = 182
input_image_size = 160
ret, frame = self.cap.read()
frame = cv2.resize(frame, (0,0), fx=1, fy=1) #resize frame (optional)
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(frame, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
print('Detected_FaceNum: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces,4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][2] >= len(frame[0]) or bb[i][3] >= len(frame):
print('Face is very close!')
continue
cropped.append(frame[bb[i][1]:bb[i][3], bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(misc.imresize(cropped[i], (image_size, image_size), interp='bilinear'))
scaled[i] = cv2.resize(scaled[i], (input_image_size,input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(-1,input_image_size,input_image_size,3))
feed_dict = {images_placeholder: scaled_reshape[i], phase_train_placeholder: False}
emb_array[0, :] = sess.run(embeddings, feed_dict=feed_dict)
cv2.rectangle(frame, (bb[i][0], bb[i][1]), (bb[i][2], bb[i][3]), (0, 255, 0), 2) #boxing face
#plot result idx under box
text_x = bb[i][0]
text_y = bb[i][3] + 20
crop_img = frame[(bb[i][1]):(bb[i][3]), (bb[i][0]):(bb[i][2])]
cv2.imwrite("final2.png", crop_img)
image = open('final2.png', 'rb')
files = {'imageSrc':image}
#cv2.putText(frame, "Manohar", (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL,
# 1, (0, 0, 255), thickness=1, lineType=2)
response = requests.post(api_url_base, files=files, headers=headers)
if response.status_code == 200:
api_response = json.loads(response.content.decode('utf-8'))
print (api_response)
if api_response['images'][0]['transaction']['face_id'] == 1:
cv2.putText(frame, "Unknown", (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (0, 0, 255), thickness=1, lineType=2)
else:
print(api_response['images'][0]['transaction']['face_id'])
Identified = api_response['images'][0]['candidates'][0]['subject_id']
if api_response['images'][0]['candidates'][0]['confidence'] >= 0.70:
cv2.putText(frame, Identified, (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (0, 0, 255), thickness=1, lineType=2)
else:
None
else:
print ("error code: ",response.status_code)
if ret:
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
else:
return None
def get_video_item(self, img_path):
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(
gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, npy)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 1000
image_size = 182
input_image_size = 160
HumanNames = os.listdir(train_img)
HumanNames.sort()
print('Loading Modal')
facenet.load_model(modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
classifier_filename_exp = os.path.expanduser(
classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
video_capture = cv2.VideoCapture()
video_capture.open('./cache/short_hamilton_clip.mp4') # False
#print(img_path)
print(video_capture.read())
c = 0
print('Start Recognition')
prevTime = 0
ret, frame = video_capture.read()
while (True):
#gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#frame = cv2.resize(frame, (0,0), fx=0.5, fy=0.5) #resize frame (optional)
curTime = time.time() + 1 # calc fps
timeF = frame_interval
if (c % timeF == 0):
find_results = []
#if frame.ndim == 2:
#frame = facenet.to_rgb(frame)
#frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
frame, minsize, pnet, rnet, onet, threshold,
factor)
nrof_faces = bounding_boxes.shape[0]
print('Detected_FaceNum: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(frame.shape)[0:2]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][
2] >= len(frame[0]) or bb[i][3] >= len(
frame):
print('Face is very close!')
continue
cropped.append(frame[bb[i][1]:bb[i][3],
bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(
misc.imresize(cropped[i],
(image_size, image_size),
interp='bilinear'))
scaled[i] = cv2.resize(
scaled[i],
(input_image_size, input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(
-1, input_image_size, input_image_size, 3))
feed_dict = {
images_placeholder: scaled_reshape[i],
phase_train_placeholder: False
}
emb_array[0, :] = sess.run(embeddings,
feed_dict=feed_dict)
predictions = model.predict_proba(emb_array)
print(predictions)
best_class_indices = np.argmax(predictions,
axis=1)
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
# print("predictions")
print(best_class_indices, ' with accuracy ',
best_class_probabilities)
# print(best_class_probabilities)
if best_class_probabilities > 0.53:
cv2.rectangle(frame, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]),
(0, 255, 0), 2) #boxing face
#plot result idx under box
text_x = bb[i][0]
text_y = bb[i][3] + 20
print('Result Indices: ',
best_class_indices[0])
print(HumanNames)
for H_i in HumanNames:
if HumanNames[
best_class_indices[0]] == H_i:
result_names = HumanNames[
best_class_indices[0]]
item = dict(prob='1',
kind=result_names)
else:
item = dict(prob='1',
kind='No face')
#cv2.putText(frame, result_names, (text_x, text_y), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), thickness=1, lineType=2)
else:
item = dict(prob='1', kind='Alignment Failure')
print('Alignment Failure')
# c+=1
cv2.imshow('Video', frame)
#if cv2.waitKey(1) & 0xFF == ord('q'):
#break
item = dict(prob='4', kind='Failure')
video_capture.release()
#cv2.destroyAllWindows()
return item
def det(runt):
input_video = "akshay_mov.mp4"
modeldir = './model/20170511-185253.pb'
classifier_filename = './class/classifier.pkl'
npy = ''
train_img = "./train_img"
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, npy)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
frame_interval = 3
batch_size = 1000
image_size = 182
input_image_size = 160
HumanNames = os.listdir(train_img)
HumanNames.sort()
print(HumanNames)
now = datetime.datetime.now()
print("printing to firebase")
if runt == 1:
for a in range(1, len(HumanNames)):
student = {HumanNames[a]: "Absent"}
db.child("Attendance").child(now.year).child(
now.month).child(now.day).child(now.hour).update(
student, user['idToken'])
print('Loading Modal')
facenet.load_model(modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
classifier_filename_exp = os.path.expanduser(classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
video_capture = cv2.VideoCapture(0)
c = 0
print('Start Recognition')
runt = runt + 1
prevTime = 0
while True:
ret, frame = video_capture.read()
frame = cv2.resize(frame, (0, 0), fx=0.5,
fy=0.5) #resize frame (optional)
curTime = time.time() + 1 # calc fps
timeF = frame_interval
if (c % timeF == 0):
find_results = []
if frame.ndim == 2:
frame = facenet.to_rgb(frame)
frame = frame[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
frame, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
print('Detected_FaceNum: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(frame.shape)[0:2]
cropped = []
scaled = []
scaled_reshape = []
bb = np.zeros((nrof_faces, 4), dtype=np.int32)
for i in range(nrof_faces):
emb_array = np.zeros((1, embedding_size))
bb[i][0] = det[i][0]
bb[i][1] = det[i][1]
bb[i][2] = det[i][2]
bb[i][3] = det[i][3]
# inner exception
if bb[i][0] <= 0 or bb[i][1] <= 0 or bb[i][
2] >= len(
frame[0]) or bb[i][3] >= len(frame):
print('Face is very close!')
continue
cropped.append(frame[bb[i][1]:bb[i][3],
bb[i][0]:bb[i][2], :])
cropped[i] = facenet.flip(cropped[i], False)
scaled.append(
misc.imresize(cropped[i],
(image_size, image_size),
interp='bilinear'))
scaled[i] = cv2.resize(
scaled[i],
(input_image_size, input_image_size),
interpolation=cv2.INTER_CUBIC)
scaled[i] = facenet.prewhiten(scaled[i])
scaled_reshape.append(scaled[i].reshape(
-1, input_image_size, input_image_size, 3))
feed_dict = {
images_placeholder: scaled_reshape[i],
phase_train_placeholder: False
}
emb_array[0, :] = sess.run(embeddings,
feed_dict=feed_dict)
predictions = model.predict_proba(emb_array)
print(predictions)
best_class_indices = np.argmax(predictions, axis=1)
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
# print("predictions")
print(best_class_indices, ' with accuracy ',
best_class_probabilities)
# print(best_class_probabilities)
if best_class_probabilities > 0.43:
cv2.rectangle(frame, (bb[i][0], bb[i][1]),
(bb[i][2], bb[i][3]),
(0, 255, 0), 2) #boxing face
#plot result idx under box
text_x = bb[i][0]
text_y = bb[i][3] + 20
print('Result Indices: ',
best_class_indices[0] + 1)
print(HumanNames)
now = datetime.datetime.now()
print("printing to firebase")
student = {
HumanNames[best_class_indices[0] + 1]:
"Present"
}
db.child("Attendance").child(now.year).child(
now.month).child(now.day).child(
now.hour).update(
student, user['idToken'])
for H_i in HumanNames:
if HumanNames[best_class_indices[0] +
1] == H_i:
result_names = HumanNames[
best_class_indices[0] + 1]
cv2.putText(
frame,
result_names, (text_x, text_y),
cv2.FONT_HERSHEY_COMPLEX_SMALL,
1, (0, 0, 255),
thickness=1,
lineType=2)
else:
print('Alignment Failure')
# c+=1
cv2.imshow('Video', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
video_capture.release()
cv2.destroyAllWindows()
