def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
if not weight_file:
weight_file = get_file("weights.18-4.06.hdf5", pretrained_model, cache_subdir="pretrained_models",
file_hash=modhash, cache_dir=os.path.dirname(os.path.abspath(__file__)))
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
for img in yield_images():
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
if len(detected) > 0:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - 0.4 * w), 0)
yw1 = max(int(y1 - 0.4 * h), 0)
xw2 = min(int(x2 + 0.4 * w), img_w - 1)
yw2 = min(int(y2 + 0.4 * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, d in enumerate(detected):
label = "{}, {}".format(int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M")
draw_label(img, (d.left(), d.top()), label)
cv2.imshow("result", img)
key = cv2.waitKey(30)
if key == 27:
break
def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
if not weight_file:
weight_file = get_file("weights.18-4.06.hdf5", pretrained_model, cache_subdir="pretrained_models",
file_hash=modhash, cache_dir=os.path.dirname(os.path.abspath(__file__)))
# load model and weights
img_size = 64
batch_size = 32
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
dataset_root = Path(__file__).parent.joinpath("appa-real", "appa-real-release")
validation_image_dir = dataset_root.joinpath("valid")
gt_valid_path = dataset_root.joinpath("gt_avg_valid.csv")
image_paths = list(validation_image_dir.glob("*_face.jpg"))
faces = np.empty((batch_size, img_size, img_size, 3))
ages = []
image_names = []
for i, image_path in tqdm(enumerate(image_paths)):
faces[i % batch_size] = cv2.resize(cv2.imread(str(image_path), 1), (img_size, img_size))
image_names.append(image_path.name[:-9])
if (i + 1) % batch_size == 0 or i == len(image_paths) - 1:
results = model.predict(faces)
ages_out = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages_out).flatten()
ages += list(predicted_ages)
# len(ages) can be larger than len(image_names) due to the last batch, but it's ok.
name2age = {image_names[i]: ages[i] for i in range(len(image_names))}
df = pd.read_csv(str(gt_valid_path))
appa_abs_error = 0.0
real_abs_error = 0.0
for i, row in df.iterrows():
appa_abs_error += abs(name2age[row.file_name] - row.apparent_age_avg)
real_abs_error += abs(name2age[row.file_name] - row.real_age)
print("MAE Apparent: {}".format(appa_abs_error / len(image_names)))
print("MAE Real: {}".format(real_abs_error / len(image_names)))
def main():
# args = get_args()
depth = 16
k = 8
margin = 0.4
image_dir = "images/estimation_test/"
weight_file = get_file("weights.28-3.73.hdf5",
pretrained_model,
cache_subdir="estimation_models",
file_hash=modhash,
cache_dir=str(Path(__file__).resolve().parent))
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
image_generator = yield_images_from_dir(
image_dir) if image_dir else yield_images()
for img in image_generator:
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
# if face is detected
if len(detected) == 1:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(
), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - margin * w), 0)
yw1 = max(int(y1 - margin * h), 0)
xw2 = min(int(x2 + margin * w), img_w - 1)
yw2 = min(int(y2 + margin * h), img_h - 1)
y1_save = max(y1, 0)
y2_save = min(y2, img_h - 1)
x1_save = max(x1, 0)
x2_save = min(x2, img_w - 1)
croppedImage = img[y1_save:y2_save, x1_save:x2_save]
cv2.imwrite("images/test/test_1_cropped.png", croppedImage)
file = open('imageScale.txt', 'w')
file.write(
str(x1_save) + '\n' + str(x2_save) + '\n' + str(y1_save) +
'\n' + str(y2_save))
file.close()
img_original = img.copy()
cv2.imwrite('images/estimation_test/test_1.png', img_original)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(
img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
# predict ages of the detected faces
results = model.predict(faces)
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, d in enumerate(detected):
label = "{}".format(int(predicted_ages[i]))
draw_label(img, (d.left(), d.top()), label)
return img, predicted_ages[0], len(detected)
elif len(detected) > 1:
return img, -1, len(detected)
else:
return img, -1, 0
class AgeGender(object):
def __init__(self, depth=16, width=8, face_size=64):
self.model = WideResNet(face_size, depth=depth, k=width)()
model_path = os.path.join(os.getcwd(),
"pretrained_models").replace("//", "\\")
weight_file_path = get_file('weights.18-4.06.hdf5',
WEIGHTS_PATH,
cache_subdir=model_path)
self.model.load_weights(weight_file_path)
def detect_face(self, video, outpath_path):
video_capture = cv2.VideoCapture(os.path.join("video_files", video))
frame_count = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
print("\nFRAME COUNT: ", str(frame_count) + "\n")
writer = None
print("EXTRACTING FRAMES AND PERFORMING PREDICTION.\n")
while True:
grab, frame = video_capture.read()
if grab is True:
detected_faces = preprocess(frame)
else:
break
if detected_faces is not ():
face_images = np.empty((len(detected_faces), 64, 64, 3))
for i, face in enumerate(detected_faces):
face_image, cropped_img = cropping(frame,
face,
margin=50,
size=64)
(x, y, w, h) = cropped_img
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 200, 0),
2)
face_images[i, :, :, :] = face_image
results = self.model.predict(face_images)
genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
ages = results[1].dot(ages).flatten()
label = "{}, {}".format(
int(ages[i]), "F" if genders[i][0] > 0.5 else "M")
labeling(frame, (face[0], face[1]), label)
if writer is None:
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
writer = cv2.VideoWriter(outpath_path, fourcc, 30,
((frame.shape[1], frame.shape[0])),
True)
writer.write(frame)
cv2.waitKey(1)
video_capture.release()
writer.release()
cv2.destroyAllWindows()
def test(mtcnn, id_data, args, sess, embeddings, images_placeholder,
phase_train_placeholder, count):
WRN_WEIGHTS_PATH = ".\\pretrained_models\\weights.18-4.06.hdf5"
face_size = 64
model = WideResNet(64, depth=16, k=8)()
model_dir = os.path.join(os.getcwd(),
"pretrained_models").replace("//", "\\")
fpath = get_file('weights.18-4.06.hdf5',
WRN_WEIGHTS_PATH,
cache_subdir=model_dir)
model.load_weights(fpath)
cap = cv2.VideoCapture(0)
frame_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
#count=0
show_landmarks = False
show_bb = False
show_id = True
show_fps = False
#show_train = False
#real=0
while True:
start = time.time()
_, frame = cap.read()
#Locate faces and landmarks in frame
face_patches, padded_bounding_boxes, landmarks, bounding_boxes = detect_and_align.detect_faces(
frame, mtcnn)
face_imgs = np.empty((len(face_patches), face_size, face_size, 3))
for i, bb in enumerate(padded_bounding_boxes):
face_img, cropped = crop_face(frame, (bb[0], bb[1], 180, 180),
margin=40,
size=face_size)
(x, y, w, h) = cropped
#cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 200, 0), 2)
face_imgs[i, :, :, :] = face_img
if len(face_imgs) > 0:
results = model.predict(face_imgs)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
for i, face in enumerate(padded_bounding_boxes):
label = "{}, {}".format(
int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M")
font = cv2.FONT_HERSHEY_SIMPLEX
font_scale = 1
thickness = 2
size = cv2.getTextSize(label, font, font_scale, thickness)[0]
x, y = (face[0], face[1])
cv2.rectangle(frame, (x, y - size[1]), (x + size[0], y),
(255, 0, 0), cv2.FILLED)
cv2.putText(frame, label, (face[0], face[1]), font, font_scale,
(255, 255, 255), thickness)
#IdData.draw_label(frame, (face[0], face[1]), label)
face_patches = np.stack(face_patches)
feed_dict = {
images_placeholder: face_patches,
phase_train_placeholder: False
}
embs = sess.run(embeddings, feed_dict=feed_dict)
print("Matches in frame:")
matching_ids, matching_distances = id_data.find_matching_ids(embs)
for bb, landmark, matching_id, dist in zip(padded_bounding_boxes,
landmarks, matching_ids,
matching_distances):
if matching_id is None:
matching_id = "Unknown"
print("Unknown! Couldn't fint match.")
else:
print("Hi %s! Distance: %1.4f" % (matching_id, dist))
if show_id:
font = cv2.FONT_HERSHEY_SIMPLEX
#count +=1
cv2.putText(frame, matching_id, (bb[0], bb[3]), font, 1,
(0, 225, 0), 1, cv2.LINE_AA)
#cv2.putText(frame, real , (100,100), font, 1, (255, 255, 255), 1, cv2.LINE_AA)
cv2.rectangle(frame, (bb[0], bb[1]), (bb[2], bb[3]),
(255, 0, 0), 2)
if show_landmarks:
for j in range(5):
size = 1
top_left = (int(landmark[j]) - size,
int(landmark[j + 5]) - size)
bottom_right = (int(landmark[j]) + size,
int(landmark[j + 5]) + size)
cv2.rectangle(frame, top_left, bottom_right,
(255, 0, 255), 2)
#if show_train:
else:
print("Couldn't find a face")
end = time.time()
seconds = end - start
fps = round(1 / seconds, 2)
if show_fps:
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(frame, str(fps), (0, int(frame_height) - 5), font, 1,
(255, 255, 255), 1, cv2.LINE_AA)
cv2.imshow("frame", frame)
key = cv2.waitKey(1)
if key == ord("q"):
break
elif key == ord("l"):
show_landmarks = not show_landmarks
elif key == ord("b"):
show_bb = not show_bb
elif key == ord("i"):
show_id = not show_id
elif key == ord("f"):
show_fps = not show_fps
elif key == ord("s"):
count = count + 1
if count > 10:
continue
gin = dataSetGenerator.gv()
key = input('Loaded images,press any key to continue')
if key == ord('y'):
test(mtcnn, id_data, args, sess, embeddings,
images_placeholder, phase_train_placeholder, count)
else:
test(mtcnn, id_data, args, sess, embeddings,
images_placeholder, phase_train_placeholder, count)
elif key == ord('t'):
cap.release()
cv2.destroyAllWindows()
main(args)
cap.release()
cv2.destroyAllWindows()
def detector(video_input, video_output):
# parameters for loading data and images
detection_model_path = '../trained_models/detection_models/haarcascade_frontalface_default.xml'
emotion_model_path = '../trained_models/emotion_models/fer2013_mini_XCEPTION.102-0.66.hdf5'
emotion_labels = get_labels('fer2013')
gender_model_path = '../trained_models/gender_models/simple_CNN.81-0.96.hdf5'
gender_labels = get_labels('imdb')
font = cv2.FONT_HERSHEY_SIMPLEX
gender_to_cnt = {}
emotion_to_cnt = {}
age_to_cnt = {}
# hyper-parameters for bounding boxes shape
frame_window = 10
emotion_offsets = (20, 40)
gender_offsets = (10, 10)
# loading models
face_detection = load_detection_model(detection_model_path)
emotion_classifier = load_model(emotion_model_path, compile=False)
# getting input model shapes for inference
emotion_target_size = emotion_classifier.input_shape[1:3]
gender_classifier = load_model(gender_model_path, compile=False)
gender_target_size = gender_classifier.input_shape[1:3]
depth = 16
k = 8
weight_file = "weights.18-4.06.hdf5"
# load model and weights
gender_age_prediction_img_size = 64
model = WideResNet(gender_age_prediction_img_size, depth=depth, k=k)()
model.load_weights(weight_file)
cnn_face_detector = dlib.cnn_face_detection_model_v1(
'mmod_human_face_detector.dat')
def pipeline(bgr_image):
bgr_image = cv2.resize(bgr_image, (640, 360))
faces = cnn_face_detector(bgr_image, 1)
global total_faces
total_faces = total_faces + len(faces)
gray_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2GRAY)
rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB)
for face in faces:
x1, y1, x2, y2, w, h = face.rect.left(), face.rect.top(
), face.rect.right() + 1, face.rect.bottom() + 1, face.rect.width(
), face.rect.height()
xw1 = max(int(x1 - 0.4 * w), 0)
yw1 = max(int(y1 - 0.4 * h), 0)
xw2 = min(int(x2 + 0.4 * w), bgr_image.shape[1] - 1)
yw2 = min(int(y2 + 0.4 * h), bgr_image.shape[0] - 1)
gray_face = gray_image[yw1:yw2 + 1, xw1:xw2 + 1]
try:
gray_face = cv2.resize(gray_face, (emotion_target_size))
except:
continue
gray_face = preprocess_input(gray_face, False)
gray_face = np.expand_dims(gray_face, 0)
gray_face = np.expand_dims(gray_face, -1)
emotion_label_arg = np.argmax(
emotion_classifier.predict(gray_face))
emotion_text = emotion_labels[emotion_label_arg]
if emotion_text not in emotion_to_cnt:
emotion_to_cnt[emotion_text] = 0
emotion_to_cnt[emotion_text] = emotion_to_cnt[emotion_text] + 1
color = (255, 255, 255)
cv2.putText(rgb_image, emotion_text,
(face.rect.left(), face.rect.top() - 5),
cv2.FONT_HERSHEY_SIMPLEX, 1, color, 1, cv2.LINE_AA)
face_list = np.empty((len(faces), gender_age_prediction_img_size,
gender_age_prediction_img_size, 3))
for i in range(0, len(faces)):
face = faces[i]
x1, y1, x2, y2, w, h = face.rect.left(), face.rect.top(
), face.rect.right() + 1, face.rect.bottom() + 1, face.rect.width(
), face.rect.height()
xw1 = max(int(x1 - 0.4 * w), 0)
yw1 = max(int(y1 - 0.4 * h), 0)
xw2 = min(int(x2 + 0.4 * w), bgr_image.shape[1] - 1)
yw2 = min(int(y2 + 0.4 * h), bgr_image.shape[0] - 1)
rgb_face = rgb_image[yw1:yw2 + 1, xw1:xw2 + 1, :]
try:
face_list[i, :, :, :] = cv2.resize(
rgb_face, (gender_age_prediction_img_size,
gender_age_prediction_img_size))
except:
continue
gender_age_prediction = model.predict(face_list)
for i in range(0, len(faces)):
face = faces[i]
predicted_genders = gender_age_prediction[0]
gender_text = "FEMALE" if predicted_genders[i][0] > 0.5 else "MALE"
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = gender_age_prediction[1].dot(ages).flatten()
age_text = str(predicted_ages[i])
if gender_text not in gender_to_cnt:
gender_to_cnt[gender_text] = 0
gender_to_cnt[gender_text] = gender_to_cnt[gender_text] + 1
if age_text not in age_to_cnt:
age_to_cnt[age_text] = 0
age_to_cnt[age_text] = age_to_cnt[age_text] + 1
gender_color = (255, 0, 0) if gender_text == "MALE" else (0, 0,
255)
cv2.rectangle(rgb_image, (face.rect.left(), face.rect.top()),
(face.rect.right(), face.rect.bottom()),
gender_color, 1)
color = (255, 255, 255)
cv2.putText(rgb_image, gender_text,
(face.rect.left(), face.rect.top() - 20),
cv2.FONT_HERSHEY_SIMPLEX, 1, gender_color, 1,
cv2.LINE_AA)
cv2.putText(rgb_image, age_text,
(face.rect.left(), face.rect.top() - 35),
cv2.FONT_HERSHEY_SIMPLEX, 1, color, 1, cv2.LINE_AA)
bgr_image = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2BGR)
return bgr_image
clip2 = VideoFileClip(video_input)
white_clip = clip2.fl_image(
pipeline) # NOTE: this function expects color images!!
white_clip.write_videofile(video_output, audio=False)
# Define our model parameters
depth = 16
k = 8
weight_file = None
margin = 0.4
image_dir = None
# Get our weight file
if not weight_file:
weight_file = get_file("weights.28-3.73.hdf5", pretrained_model, cache_subdir="pretrained_models",
file_hash=modhash, cache_dir=Path(sys.argv[0]).resolve().parent)
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
detector = dlib.get_frontal_face_detector()
image_names = [f for f in listdir(image_path) if isfile(join(image_path, f))]
for image_name in image_names:
frame = cv2.imread("./images/" + image_name)
preprocessed_faces_emo = []
input_img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
detected = detector(frame, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
preprocessed_faces_emo = []
class scanning_face():
def __init__(self, flag, bgr_image):
print(os.path.abspath(''))
self.flag = flag
self.bgr_image = bgr_image
self.frq = 0
self.icon_dict, self.words_dict = load_emotion_icon()
###########
self.args = get_args()
self.depth = self.args.depth
self.k = self.args.width
self.weight_file = self.args.weight_file
self.margin = self.args.margin
###########
if not self.weight_file:
self.weight_file = get_file("weights.28-3.73.hdf5",
pretrained_model,
cache_subdir="pretrained_models",
file_hash=modhash,
cache_dir=str(
Path(__file__).resolve().parent))
# for face detection
self.detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
self.model = WideResNet(img_size, depth=self.depth, k=self.k)()
self.model.load_weights(self.weight_file)
def show_face_information(self):
# bgr_image = img
gray_image = cv2.cvtColor(self.bgr_image, cv2.COLOR_BGR2GRAY)
rgb_image = cv2.cvtColor(self.bgr_image, cv2.COLOR_BGR2RGB)
faces = detect_faces(face_detection, gray_image)
img_h, img_w, _ = np.shape(rgb_image)
for face_coordinates in faces:
x1, x2, y1, y2 = apply_offsets(face_coordinates, gender_offsets)
rgb_face = rgb_image[y1:y2, x1:x2]
x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets)
gray_face = gray_image[y1:y2, x1:x2]
try:
rgb_face = cv2.resize(rgb_face, (gender_target_size))
gray_face = cv2.resize(gray_face, (emotion_target_size))
except:
continue
# run_thread(bgr_image)
gray_face = preprocess_input(gray_face, False)
gray_face = np.expand_dims(gray_face, 0)
gray_face = np.expand_dims(gray_face, -1)
emotion_label_arg = np.argmax(
emotion_classifier.predict(gray_face))
emotion_text = emotion_labels[emotion_label_arg]
emotion_window.append(emotion_text)
# emotion_window.append(English_2_chinese_emotion(emotion_text))
rgb_face = np.expand_dims(rgb_face, 0)
rgb_face = preprocess_input(rgb_face, False)
gender_prediction = gender_classifier.predict(rgb_face)
gender_label_arg = np.argmax(gender_prediction)
gender_text = gender_labels[gender_label_arg]
# gender_window.append(English_2_chinese_gender(gender_text))
set_icon = emotion_text + "_" + gender_text
print(set_icon)
icon_img = self.icon_dict[set_icon]
words_img = self.words_dict[set_icon]
# if len(gender_window) > frame_window:
# emotion_window.pop(0)
# gender_window.pop(0)
# try:
# emotion_mode = mode(emotion_window)
# gender_mode = mode(gender_window)
# except:
# continue
if gender_text == gender_labels[0]:
color = (0, 0, 255)
else:
color = (255, 0, 0)
###################
if (self.frq % 60 == 0):
# detect faces using dlib detector
detected = self.detector(rgb_image, 1)
print(detected)
faces_age = np.empty((len(detected), img_size, img_size, 3))
if len(detected) > 0:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(), d.right(
) + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - self.margin * w), 0)
yw1 = max(int(y1 - self.margin * h), 0)
xw2 = min(int(x2 + self.margin * w), img_w - 1)
yw2 = min(int(y2 + self.margin * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces_age[i, :, :, :] = cv2.resize(
img[yw1:yw2 + 1, xw1:xw2 + 1, :],
(img_size, img_size))
# predict ages and genders of the detected faces
results = self.model.predict(faces_age)
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
print(predicted_ages)
###################
self.frq += 1
if ((face_coordinates[0] - face_coordinates[2]) > 50
and (face_coordinates[0] - face_coordinates[2]) < 180
and (face_coordinates[1] - 80) > 20):
solid_box = draw_solid_box(face_coordinates, rgb_image)
draw_bounding_box(face_coordinates, rgb_image, color)
solid_box = Addemotion(face_coordinates, solid_box, icon_img)
solid_box = Addemotion_word(face_coordinates, solid_box,
words_img)
draw_text(face_coordinates, rgb_image,
str(int(predicted_ages)), (255, 255, 255), 0, -20, 1,
1)
return rgb_image
# Size of the images
if train_model == "Inception":
img_width, img_height = 139, 139
elif train_model == "ResNet":
img_width, img_height = 197, 197
emotions = ['Anger', 'Disgust', 'Fear', 'Happiness', 'Sadness', 'Surprise', 'Neutral']
# Reinstantiate the fine-tuned model (Also compiling the model using the saved training configuration (unless the model was never compiled))
emo_model = load_model('./trained_models/ResNet-50.h5')
# age and gender
weight_file = None
margin = 0.4
img_size = 64
model = WideResNet(img_size, depth=16, k=8)()
model.load_weights('./trained_models/weights.28-3.73.hdf5')
def preprocess_input(image):
image = cv.resize(image, (img_width, img_height))
ret = np.empty((img_height, img_width, 3))
ret[:, :, 0] = image
ret[:, :, 1] = image
ret[:, :, 2] = image
x = np.expand_dims(ret, axis=0) # (1, XXX, XXX, 3)
if train_model == "Inception":
x /= 127.5
x -= 1.
return x
elif train_model == "ResNet":
depth = 16
width = 8
alpha = 0.8
# model=None
if 0:
CASE_PATH = "/home/merly/Documents/gender/pretrained_models/haarcascade_frontalface_alt.xml"
WRN_WEIGHTS_PATH = "https://github.com/Tony607/Keras_age_gender/releases/download/V1.0/weights.18-4.06.hdf5"
face_size = 64
depth = 16
width = 8
alpha = 0.8
model = WideResNet(face_size, depth=depth, k=width)()
model_dir = os.path.join(os.getcwd(), "pretrained_models").replace("//", "\\")
fpath = get_file('weights.18-4.06.hdf5',WRN_WEIGHTS_PATH,cache_subdir=model_dir)
print('**********************',fpath)
model.load_weights(fpath)
emotion_model_path = 'models/emotion_model.hdf5'
emotion_labels = get_labels('fer2013')
# hyper-parameters for bounding boxes shape
frame_window = 10
emotion_offsets = (20, 40)
# loading models
face_cascade = cv2.CascadeClassifier('models/haarcascade_frontalface_default.xml')
emotion_classifier = load_model(emotion_model_path)
# getting input model shapes for inference
emotion_target_size = emotion_classifier.input_shape[1:3]
class FaceImage(object):
"""
Singleton class for face recognition task
"""
CASE_PATH = "./models/haarcascade_frontalface_alt.xml"
WRN_WEIGHTS_PATH = "https://github.com/Tony607/Keras_age_gender/releases/download/V1.0/weights.18-4.06.hdf5"
def __new__(cls, weight_file=None, depth=16, width=8, face_size=64):
if not hasattr(cls, 'instance'):
cls.instance = super(FaceImage, cls).__new__(cls)
return cls.instance
def __init__(self, depth=16, width=8, face_size=64):
self.face_size = face_size
print("Loading WideResNet model...")
self.model = WideResNet(face_size, depth=depth, k=width)()
model_dir = os.path.join(os.getcwd(), "models").replace("//", "\\")
fpath = get_file('weights.18-4.06.hdf5',
self.WRN_WEIGHTS_PATH,
cache_subdir=model_dir)
self.model.load_weights(fpath)
print("Loaded WideResNet model")
# Load emotion models
print("Loading emotion model...")
self.emotion_model = emotion.load_model_dir("models")
print("Loaded emotion model")
if RECOGNIZE_FACES:
print("Loading face recognizer...")
self.face_recognizer = FaceRecognizer()
print("Loaded face recognizer")
@classmethod
def draw_label_top(cls, image, point, label, font=cv2.FONT_HERSHEY_SIMPLEX,
font_scale=1, thickness=2, alpha=OVERLAY_ALPHA):
size = cv2.getTextSize(label, font, font_scale, thickness)[0]
x, y = point
overlay = image.copy()
cv2.rectangle(overlay, (x, y - size[1]), (x + size[0], y), (255, 0, 0), cv2.FILLED)
cv2.putText(overlay, label, point, font, font_scale, (255, 255, 255), thickness)
cv2.addWeighted(overlay, alpha, image, 1 - alpha, 0, image)
@classmethod
def draw_label_bottom(cls, image, point, label, font=cv2.FONT_HERSHEY_SIMPLEX,
font_scale=0.5, thickness=1, row_index=0, alpha=OVERLAY_ALPHA):
size = cv2.getTextSize(label, font, font_scale, thickness)[0]
point = (point[0], point[1] + (row_index * size[1]))
x, y = point
overlay = image.copy()
cv2.rectangle(overlay, (x, y), (x + size[0], y + size[1]), (255, 0, 0), cv2.FILLED)
point = x, y+size[1]
cv2.putText(overlay, label, point, font, font_scale, (255, 255, 255), thickness)
cv2.addWeighted(overlay, alpha, image, 1 - alpha, 0, image)
def get_regular_face(self, img, bb):
return img[bb.top():bb.bottom()+1, bb.left():bb.right()+1, :]
def get_expanded_face(self, img, bb):
img_h, img_w, _ = np.shape(img)
x1, y1, x2, y2, w, h = bb.left(), bb.top(), bb.right() + 1, bb.bottom() + 1, bb.width(), bb.height()
xw1 = max(int(x1 - 0.4 * w), 0)
yw1 = max(int(y1 - 0.4 * h), 0)
xw2 = min(int(x2 + 0.4 * w), img_w - 1)
yw2 = min(int(y2 + 0.4 * h), img_h - 1)
return cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1, :], (self.face_size, self.face_size))
def detect_face(self, img):
# workaround for CV2 bug
img = copy.deepcopy(img)
# for face detection
detector = dlib.get_frontal_face_detector()
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
if RECOGNIZE_FACES == True:
face_bbs, identities = self.face_recognizer.identify_image_faces(img)
else:
face_bbs = detector(input_img, 1)
expanded_face_imgs = np.empty((len(face_bbs), self.face_size, self.face_size, 3))
emotion2_results = []
# Get face images
for i, bb in enumerate(face_bbs):
x1, y1, x2, y2, w, h = bb.left(), bb.top(), bb.right() + 1, bb.bottom() + 1, bb.width(), bb.height()
expanded_face_imgs[i, :, :, :] = self.get_expanded_face(img, bb)
reg_face = self.get_regular_face(img, bb)
#reg_face = copy.deepcopy(reg_face)
emotion2_results.append(emotion.emotionof(self.emotion_model, reg_face)[0])
if len(expanded_face_imgs) > 0:
# predict ages and genders of the detected faces
results = self.model.predict(expanded_face_imgs)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, bb in enumerate(face_bbs):
if RECOGNIZE_FACES == True:
# Display name
label1 = "{}".format(identities[i])
self.draw_label_bottom(img, (bb.left(), bb.bottom()), label1)
## Display age, gender and emotion
if identities[i] == "Unknown" or "customer" in identities[i]:
label2 = "{}, {}, {}".format(int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M",
emotion2_results[i])
else:
label2 = "{}".format(emotion2_results[i])
self.draw_label_bottom(img, (bb.left(), bb.bottom()+1), label2, row_index=1)
else:
## Display age, gender and emotion
label2 = "{}, {}, {}".format(int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M",
emotion2_results[i])
self.draw_label_bottom(img, (bb.left(), bb.bottom()), label2, row_index=0)
# draw face rectangles
for i, bb in enumerate(face_bbs):
x1, y1, x2, y2, w, h = bb.left(), bb.top(), bb.right() + 1, bb.bottom() + 1, bb.width(), bb.height()
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
return img
def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
margin = args.margin
if not weight_file:
weight_file = get_file("weights.28-3.73.hdf5",
pretrained_model,
cache_subdir="pretrained_models",
file_hash=modhash,
cache_dir=str(Path(__file__).resolve().parent))
folder_images = os.path.expanduser(args.input_folder)
images = []
images = glob.glob(os.path.join(folder_images, "*.png"))
images.extend(glob.glob(os.path.join(folder_images, "*.jpg")))
images.extend(glob.glob(os.path.join(folder_images, "*.jpeg")))
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
for path in tqdm.tqdm(images):
img_name = os.path.splitext(
os.path.basename(path))[0] # without file suffix
img = cv2.imread(path)
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
segment_img = cv2.imread(
os.path.join(args.output_folder, "segmented/", img_name + ".png"))
# if not img_name == "0377":
# continue
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
# predict ages and genders of the detected faces
if len(detected) > 0:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(
), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - margin * w), 0)
yw1 = max(int(y1 - margin * h), 0)
xw2 = min(int(x2 + margin * w), img_w - 1)
yw2 = min(int(y2 + margin * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(
img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# process results
# remove all female detected segments
for i, d in enumerate(detected):
gender = "M" if predicted_genders[i][0] < 0.5 else "F"
label = "{}, {}".format(int(predicted_ages[i]), gender)
print(path, label)
draw_label(img, (d.left(), d.top()), label)
if gender == "F":
centerX = int(d.left() + d.width() / 2)
centerY = int(d.top() + d.height() / 2)
segment_color = segment_img[centerY, centerX]
segment_pixels_indices = np.where(
np.all(segment_img == segment_color, axis=-1))
segment_img[segment_pixels_indices] = [0, 0, 0]
# make all remaining segements white
non_black_pixels_indices = np.any(segment_img != [0, 0, 0], axis=-1)
segment_img[non_black_pixels_indices] = [255, 255, 255]
# save new binary mask
out_filename = os.path.join(args.output_folder,
"age_gender_masked_binary/",
img_name + ".png")
os.makedirs(os.path.dirname(out_filename), exist_ok=True)
cv2.imwrite(out_filename, segment_img)
# save debug image
out_filename = os.path.join(args.output_folder, "age_gender/",
img_name + ".png")
os.makedirs(os.path.dirname(out_filename), exist_ok=True)
cv2.imwrite(out_filename, img)
if __name__ == "__main__":
os.environ['CUDA_VISIBLE_DEVICES'] = '3'
model_path = 'model'
if not os.path.exists(model_path):
os.mkdir(model_path)
image_size = 128
batch_size = 64
nb_epochs = 30
# depth of network (should be 10, 16, 22, 28, ...)
# width of network (should be 2, 4, 6, 8, 10, ...)
model = WideResNet(image_size, depth=16, k=4)()
model.load_weights('model/weights.24-5.84.hdf5', by_name=True)
sgd = SGD(lr=0.002, momentum=0.9, nesterov=True)
model.compile(
optimizer=sgd,
loss=["categorical_crossentropy", "categorical_crossentropy"])
gen = Generator(train_full_path="images/imdb_detect/imdb.csv", \
valid_full_path="images/wiki_detect/wiki.csv", \
image_size=image_size, \
batch_size=batch_size)
callbacks = [
LearningRateScheduler(schedule=Schedule(nb_epochs)),
ModelCheckpoint("model/weights.{epoch:02d}-{val_loss:.2f}.hdf5",
verbose=1,
save_weights_only=True)
class FaceCV(object):
"""
Singleton class for face recongnition task
"""
CASE_PATH = "./pretrained_models/haarcascade_frontalface_alt.xml"
WRN_WEIGHTS_PATH = "---IMBD || WIKI weights path (Alredy given with Aswin Sir)"
#Establishing SuperClass
def __new__(cls, weight_file=None, depth=16, width=8, face_size=64):
if not hasattr(cls, 'instance'):
cls.instance = super(FaceCV, cls).__new__(cls)
return cls.instance
#Variables intilization
def __init__(self, depth=16, width=8, face_size=64):
self.face_size = face_size
self.model = WideResNet(face_size, depth=depth, k=width)()
model_dir = os.path.join(os.getcwd(), "pretrained_models").replace("//", "\\")
fpath = get_file('weights.18-4.06.hdf5',
self.WRN_WEIGHTS_PATH,
cache_subdir=model_dir)
self.model.load_weights(fpath)
""" I have commented out this medthod since we dont need to see the out put in real time once on the Jetson"""
# @classmethod
# def draw_label(cls, image, point, label, font=cv2.FONT_HERSHEY_SIMPLEX,
# font_scale=1, thickness=2):
# size = cv2.getTextSize(label, font, font_scale, thickness)[0]
# x, y = point
# cv2.rectangle(image, (x, y - size[1]), (x + size[0], y), (255, 0, 0), cv2.FILLED)
# cv2.putText(image, label, point, font, font_scale, (255, 255, 255), thickness)
def crop_face(self, imgarray, section, margin=40, size=64):
"""
:param imgarray: full image
:param section: face detected area (x, y, w, h)
:param margin: add some margin to the face detected area to include a full head
:param size: the result image resolution with be (size x size)
:return: resized image in numpy array with shape (size x size x 3)
"""
img_h, img_w, _ = imgarray.shape
if section is None:
section = [0, 0, img_w, img_h]
(x, y, w, h) = section
margin = int(min(w,h) * margin / 100)
x_a = x - margin
y_a = y - margin
x_b = x + w + margin
y_b = y + h + margin
if x_a < 0:
x_b = min(x_b - x_a, img_w-1)
x_a = 0
if y_a < 0:
y_b = min(y_b - y_a, img_h-1)
y_a = 0
if x_b > img_w:
x_a = max(x_a - (x_b - img_w), 0)
x_b = img_w
if y_b > img_h:
y_a = max(y_a - (y_b - img_h), 0)
y_b = img_h
cropped = imgarray[y_a: y_b, x_a: x_b]
resized_img = cv2.resize(cropped, (size, size), interpolation=cv2.INTER_AREA)
resized_img = np.array(resized_img)
return resized_img, (x_a, y_a, x_b - x_a, y_b - y_a)
def main():
global s3
# s3 = boto3.client('s3')
session = boto3.Session(aws_access_key_id=AWS_SERVER_PUBLIC_KEY,
aws_secret_access_key=AWS_SERVER_SECRET_KEY)
s3 = session.resource('s3')
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
margin = args.margin
image_dir = args.image_dir
if not weight_file:
weight_file = get_file("weights.28-3.73.hdf5",
pretrained_model,
cache_subdir="pretrained_models",
file_hash=modhash,
cache_dir=str(Path(__file__).resolve().parent))
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
image_generator = yield_images_from_dir(
image_dir) if image_dir else yield_images()
print('OK. Ready!')
for img in image_generator:
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
if len(detected) > 0:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(
), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - margin * w), 0)
yw1 = max(int(y1 - margin * h), 0)
xw2 = min(int(x2 + margin * w), img_w - 1)
yw2 = min(int(y2 + margin * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(
img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, d in enumerate(detected):
label = "{}, {}".format(
int(predicted_ages[i] - 5),
"M" if predicted_genders[i][0] < 0.5 else "F")
draw_label(img, (d.left(), d.top()), label)
cv2.imshow("result", img)
key = cv2.waitKey(-1) if image_dir else cv2.waitKey(30)
if key == 27: # ESC
break
if key == 32: # SPACE
frame_id = int(time.time())
# _,embeddings = get_face_embeddings_from_image(img)
# embedded = len(embeddings)==len(detected)
# if not embedded:
# embeddings = [None]*len(detected)
# print('Oops. Please try again!')
# return None
response = [
[
str(frame_id) + str(i + 1).zfill(2),
str(pd.to_datetime('now')),
str(frame_id),
str(i + 1),
str(int(predicted_ages[i]) - 5),
"M" if predicted_genders[i][0] < 0.5 else "F"
# ,str(embeddings[i])
] for i, d in enumerate(detected)
]
j_response = [
{
'key':
int(str(frame_id) + str(i + 1).zfill(2)),
'datetime':
str(pd.to_datetime('now')),
'frame_id':
frame_id,
'frame_face_id':
i + 1,
'predicted_ages':
str(int(predicted_ages[i]) - 5),
'predicted_genders':
"M" if predicted_genders[i][0] < 0.5 else "F"
# ,'embeddings':list(embeddings[i])
} for i, d in enumerate(detected)
]
output = '\n'.join(['|'.join(i) for i in response])
j_output = '\n'.join([str(j) for j in j_response])
print(j_output)
try:
upload(j_output)
except:
print('Connection to S3 failed.')
if key == 115: # s
print(
'Please enter email address to send result to (Consent required).'
)
print('Sending to ' + input(), end='...\n')
output = '\n'.join(['\t'.join(i) for i in response])
print(output)
def classify_process():
print("* Loading model...")
img_size = 64
model = WideResNet(img_size, depth=16, k=8)()
model.load_weights("checkpoints168/weights.48-3.62.hdf5")
print("* Model loaded")
while True:
body = db.lpop(settings.IMAGE_QUEUE)
if body is not None:
body = json.loads(body.decode("utf-8"))
image = helpers.base64_decode_image(body["image"], body["height"])
bounding_boxes = demo_mtcnn.detect_face(image)
margin = 0.4
faces = np.empty((len(bounding_boxes), 64, 64, 3))
for i, bounding_box in enumerate(bounding_boxes):
x = int(bounding_box[0])
y = int(bounding_box[1])
w = int(bounding_box[2])
h = int(bounding_box[3])
img_h, img_w, _ = np.shape(image)
_x = max(int(x - margin * w), 0)
_y = max(int(y - margin * h), 0)
_x2 = min(int(x + w + margin * w), img_w - 1)
_y2 = min(int(y + h + margin * h), img_h - 1)
# cv2.rectangle(image, (x, y), (x+w, y+h), (0, 155, 255), 2)
faces[i, :, :, :] = cv2.resize(
image[_y:_y2 + 1, _x:_x2 + 1, :], (64, 64))
# cv2.rectangle(image, (_x, _y), (_x2, _y2), (0, 155, 255), 2)
# cv2.imshow("",faces[0])
# key = cv2.waitKey(-1)
# if key==27:
# break
if len(faces) > 0:
results = model.predict(faces)
# results = imagenet_utils.decode_predictions(preds)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
predicted_ages = predicted_ages.tolist()
predicted_genders = [
gender.tolist() for gender in predicted_genders
]
print(type(predicted_genders[0]))
print(type(predicted_ages))
# for i, bounding_box in enumerate(bounding_boxes):
# label = "{}, {}".format(int(predicted_ages[i]),"M" if predicted_genders[i][0] < 0.5 else "F")
# demo_mtcnn.draw_label(image, (int(bounding_box[0]), int(bounding_box[1])), label)
# cv2.imshow("",image)
# cv2.waitKey(1000)
print("done")
# image_out = helpers.base64_encode_image(image).decode('utf-8')
# db.set(body["id"], json.dumps(image_out))
data = {
"boudingboxes": bounding_boxes.tolist(),
"ages": predicted_ages,
"genders": predicted_genders
}
db.set(body["id"], json.dumps(data))
else:
print("No data")
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
import cv2
import os
from time import sleep
import numpy as np
import argparse
from wide_resnet import WideResNet
depth = 16
width = 8
face_size = 64
model = WideResNet(face_size, depth=depth, k=width)()
model.load_weights("weights.18-4.06.hdf5")
def draw_label(image,
point,
label,
font=cv2.FONT_HERSHEY_SIMPLEX,
font_scale=1,
thickness=2):
size = cv2.getTextSize(label, font, font_scale, thickness)[0]
x, y = point
cv2.rectangle(image, (x, y - size[1]), (x + size[0], y), (255, 0, 0),
cv2.FILLED)
cv2.putText(image, label, point, font, font_scale, (255, 255, 255),
thickness)
def crop_face(imgarray, section, margin=40, size=64):
img_h, img_w, _ = imgarray.shape
if section is None:
class FaceCV(object):
FACE_DETECTOR = settings.MODEL_PARA['detect_faces_model_path']
# WRN_WEIGHTS_PATH = "https://github.com/Tony607/Keras_age_gender/releases/download/V1.0/weights.18-4.06.hdf5"
AGE_GENDER_PREDICTOR = settings.MODEL_PARA['age_gender_prediction_path']
"""
Singleton class for face recongnition task
"""
def __new__(cls, weight_file=None, depth=16, width=8, face_size=64):
if not hasattr(cls, 'instance'):
cls.instance = super(FaceCV, cls).__new__(cls)
return cls.instance
def __init__(self, depth=16, width=8, face_size=64):
self.face_size = face_size
self.model = WideResNet(face_size, depth=depth, k=width)()
self.model.load_weights(self.AGE_GENDER_PREDICTOR)
@classmethod
def draw_label(cls,
image,
point,
label,
font=cv2.FONT_HERSHEY_SIMPLEX,
font_scale=1,
thickness=2):
size = cv2.getTextSize(label, font, font_scale, thickness)[0]
x, y = point
cv2.rectangle(image, (x, y - size[1]), (x + size[0], y), (255, 0, 0),
cv2.FILLED)
cv2.putText(image, label, point, font, font_scale, (255, 255, 255),
thickness)
def crop_face(self,
imgarray,
section,
margin=settings.MARGIN,
size=settings.FACE_SIZE):
"""
:param imgarray: full image
:param section: face detected area (x, y, w, h)
:param margin: add some margin to the face detected area to include a full head
:param size: the result image resolution with be (size x size)
:return: resized image in numpy array with shape (size x size x 3)
"""
img_h, img_w, _ = imgarray.shape
if section is None:
section = [0, 0, img_w, img_h]
(x, y, w, h) = section
margin = int(min(w, h) * margin / 100)
x_a = x - margin
y_a = y - margin
x_b = x + w + margin
y_b = y + h + margin
if x_a < 0:
x_b = min(x_b - x_a, img_w - 1)
x_a = 0
if y_a < 0:
y_b = min(y_b - y_a, img_h - 1)
y_a = 0
if x_b > img_w:
x_a = max(x_a - (x_b - img_w), 0)
x_b = img_w
if y_b > img_h:
y_a = max(y_a - (y_b - img_h), 0)
y_b = img_h
cropped = imgarray[y_a:y_b, x_a:x_b]
resized_img = cv2.resize(cropped, (size, size),
interpolation=cv2.INTER_AREA)
resized_img = np.array(resized_img)
return resized_img, (x_a, y_a, x_b - x_a, y_b - y_a)
def detect_face_one_image(self, frame):
out_boxes = []
out_ages = []
out_genders = []
# load the face detector model
face_cascade = cv2.CascadeClassifier(self.FACE_DETECTOR)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray,
scaleFactor=1.2,
minNeighbors=10,
minSize=(self.face_size,
self.face_size))
# placeholder for cropped faces
face_imgs = np.empty((len(faces), self.face_size, self.face_size, 3))
print('len(faces) :{}'.format(len(faces)))
for i, face in enumerate(faces):
face_img, cropped = self.crop_face(frame,
face,
margin=40,
size=self.face_size)
(x, y, w, h) = cropped
#cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 200, 0), 2)
out_boxes.append(cropped)
face_imgs[i, :, :, :] = face_img
print(face_imgs.shape)
print("out_boxes : {}".format(out_boxes))
if len(face_imgs) > 0:
# predict ages and genders of the detected faces
results = self.model.predict(face_imgs)
print("----doing face_imgs----------")
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, face in enumerate(faces):
out_ages.append(int(predicted_ages[i]))
out_genders.append("F" if predicted_genders[i][0] > 0.5 else "M")
# label = "{}, {}".format(int(predicted_ages[i]),
# "F" if predicted_genders[i][0] > 0.5 else "M")
# self.draw_label(frame, (face[0], face[1]), label)
print("out_boxes : {}".format(out_boxes))
return out_boxes, out_ages, out_genders
def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
if not weight_file:
weight_file = os.path.join("pretrained_models", "weights.18-4.06.hdf5")
# for face detection
#detector = dlib.face_recognition_model_v1("dlib_face_recognition_resnet_model_v1.dat")
cascade_path = "face_cascades/haarcascade_profileface.xml"
face_cascade = cv2.CascadeClassifier(cascade_path)
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
# capture video
cap = cv2.VideoCapture("people.mp4")
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
while True:
#get video frame
ret, img = cap.read()
print img.shape
if not ret:
print("error: failed to capture image")
return -1
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
#detected = detector.compute_face_descriptor(input_img, 1)
detected = face_cascade.detectMultiScale(input_img, 1.1, 2, 0, (20, 20) )
faces = np.empty((len(detected), img_size, img_size, 3))
for (x1,y1,w,h) in detected:
x2=x1+w
y2=y1+h
xw1 = max(int(x1 - 0.4 * w), 0)
yw1 = max(int(y1 - 0.4 * h), 0)
xw2 = min(int(x2 + 0.4 * w), img_w - 1)
yw2 = min(int(y2 + 0.4 * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[:,:,:] = cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
if len(detected) > 0:
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, d in enumerate(detected):
label = "{}, {}".format(int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M")
#draw_label(img, (d.left(), d.top()), label)
cv2.imshow("result", img)
#cv2.imwrite('detected.png',img)
key = cv2.waitKey(30)
if key == 27:
break
factor = 0.709 # scale factor
# Keras age & gender classification parameters
face_size = 64
age_gender_model = WideResNet(face_size, depth=16, k=8)()
age_gender_model_dir = os.path.join(os.getcwd(),
'pretrained_models').replace('//', '\\')
image_width = 1280
image_height = 720
fpath = get_file(
'weights.18-4.06.hdf5',
'https://github.com/Tony607/Keras_age_gender/releases/download/V1.0/weights.18-4.06.hdf5',
cache_dir=age_gender_model_dir)
age_gender_model.load_weights(fpath)
# Address the error: ValueError: Tensor Tensor("dense_1/Softmax:0", shape=(?, 2), dtype=float32) is not an element of this graph.
age_gender_model._make_predict_function()
# Start code from facenet/src/compare.py
print('Creating networks and loading parameters')
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = facenet.src.align.detect_face.create_mtcnn(
sess, None)
class FaceCV(object):
"""
Singleton class for face recongnition task
"""
CASE_PATH = ".\\pretrained_models\\haarcascade_frontalface_alt.xml"
WRN_WEIGHTS_PATH = "https://github.com/Tony607/Keras_age_gender/releases/download/V1.0/weights.18-4.06.hdf5"
def __new__(cls, weight_file=None, depth=16, width=8, face_size=64):
if not hasattr(cls, 'instance'):
cls.instance = super(FaceCV, cls).__new__(cls)
return cls.instance
def __init__(self, depth=16, width=8, face_size=64):
self.face_size = face_size
self.model = WideResNet(face_size, depth=depth, k=width)()
model_dir = os.path.join(os.getcwd(),
"pretrained_models").replace("//", "\\")
fpath = get_file('weights.18-4.06.hdf5',
self.WRN_WEIGHTS_PATH,
cache_subdir=model_dir)
self.model.load_weights(fpath)
@classmethod
def draw_label(cls,
image,
point,
label,
font=cv2.FONT_HERSHEY_SIMPLEX,
font_scale=1,
thickness=2):
size = cv2.getTextSize(label, font, font_scale, thickness)[0]
x, y = point
cv2.rectangle(image, (x, y - size[1]), (x + size[0], y), (255, 0, 0),
cv2.FILLED)
cv2.putText(image, label, point, font, font_scale, (255, 255, 255),
thickness)
def crop_face(self, imgarray, section, margin=40, size=64):
"""
:param imgarray: full image
:param section: face detected area (x, y, w, h)
:param margin: add some margin to the face detected area to include a full head
:param size: the result image resolution with be (size x size)
:return: resized image in numpy array with shape (size x size x 3)
"""
img_h, img_w, _ = imgarray.shape
if section is None:
section = [0, 0, img_w, img_h]
(x, y, w, h) = section
margin = int(min(w, h) * margin / 100)
x_a = x - margin
y_a = y - margin
x_b = x + w + margin
y_b = y + h + margin
if x_a < 0:
x_b = min(x_b - x_a, img_w - 1)
x_a = 0
if y_a < 0:
y_b = min(y_b - y_a, img_h - 1)
y_a = 0
if x_b > img_w:
x_a = max(x_a - (x_b - img_w), 0)
x_b = img_w
if y_b > img_h:
y_a = max(y_a - (y_b - img_h), 0)
y_b = img_h
cropped = imgarray[y_a:y_b, x_a:x_b]
resized_img = cv2.resize(cropped, (size, size),
interpolation=cv2.INTER_AREA)
resized_img = np.array(resized_img)
return resized_img, (x_a, y_a, x_b - x_a, y_b - y_a)
def detect_face(self):
face_cascade = cv2.CascadeClassifier(self.CASE_PATH)
# initialize the list of class labels MobileNet SSD was trained to
# detect, then generate a set of bounding box colors for each class
CLASSES = [
"background", "aeroplane", "bicycle", "bird", "boat", "bottle",
"bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse",
"motorbike", "person", "pottedplant", "sheep", "sofa", "train",
"tvmonitor"
]
COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))
# load our serialized model from disk
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe("MobileNetSSD_deploy.prototxt.txt",
"MobileNetSSD_deploy.caffemodel")
# initialize the video stream, allow the cammera sensor to warmup,
# and initialize the FPS counter
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
import pyttsx3
engine = pyttsx3.init()
oldObjectDict = {}
# 0 means the default video capture device in OS
video_capture = cv2.VideoCapture(0)
# infinite loop, break by key ESC
while True:
if not video_capture.isOpened():
sleep(5)
# Capture frame-by-frame
ret, frame = video_capture.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray,
scaleFactor=1.2,
minNeighbors=10,
minSize=(self.face_size,
self.face_size))
# placeholder for cropped faces
face_imgs = np.empty(
(len(faces), self.face_size, self.face_size, 3))
for i, face in enumerate(faces):
face_img, cropped = self.crop_face(frame,
face,
margin=40,
size=self.face_size)
(x, y, w, h) = cropped
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 200, 0), 2)
face_imgs[i, :, :, :] = face_img
if len(face_imgs) > 0:
# predict ages and genders of the detected faces
results = self.model.predict(face_imgs)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
allLabels = []
# draw results
for i, face in enumerate(faces):
label = "{}, {}".format(
int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M")
#self.draw_label(frame, (face[0], face[1]), label)
allLabels.append(label)
if len(allLabels) > 0:
print("age-gender : " + str(allLabels), flush=True)
#cv2.imshow('Keras Faces', frame)
frame = imutils.resize(frame, width=400)
# grab the frame dimensions and convert it to a blob
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)),
0.007843, (300, 300), 127.5)
# pass the blob through the network and obtain the detections and
# predictions
net.setInput(blob)
detections = net.forward()
objectDict = {}
# loop over the detections
for i in np.arange(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with
# the prediction
confidence = detections[0, 0, i, 2]
# filter out weak detections by ensuring the `confidence` is
# greater than the minimum confidence
if confidence > 0.8:
# extract the index of the class label from the
# `detections`, then compute the (x, y)-coordinates of
# the bounding box for the object
idx = int(detections[0, 0, i, 1])
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
objectDict[CLASSES[idx]] = confidence * 100
# draw the prediction on the frame
#label = "object - {}: {:.2f}%".format(CLASSES[idx], confidence * 100)
for clazz in objectDict:
if clazz in oldObjectDict:
if abs(oldObjectDict[clazz] - objectDict[clazz]) > 10:
print("object : " + str(clazz) + ": " +
str(oldObjectDict[clazz]),
flush=True)
oldObjectDict[clazz] = objectDict[clazz]
else:
print("object : " + str(clazz) + ": " +
str(objectDict[clazz]),
flush=True)
oldObjectDict[clazz] = objectDict[clazz]
for clazz in list(oldObjectDict):
if not clazz in objectDict:
del (oldObjectDict[clazz])
# When everything is done, release the capture
video_capture.release()
cv2.destroyAllWindows()
def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
margin = args.margin
image_dir = args.image_dir
if not weight_file:
weight_file = get_file("weights.28-3.73.hdf5",
pretrained_model,
cache_subdir="pretrained_models",
file_hash=modhash,
cache_dir=Path(__file__).resolve().parent)
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
image_generator = yield_images_from_dir(
image_dir) if image_dir else yield_images()
image_to_age_map = get_image_to_age_mapping()
age_diffs = []
negative_count = 0
for img, filename in image_generator:
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
if len(detected) > 0:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(
), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - margin * w), 0)
yw1 = max(int(y1 - margin * h), 0)
xw2 = min(int(x2 + margin * w), img_w - 1)
yw2 = min(int(y2 + margin * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(
img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
predicted_age = float(predicted_ages.tolist()[0])
image_name = filename.split('/')[-1].split('.')[0].replace(
TARGET_SUFFIX, '')
actual_age = image_to_age_map[image_name]
age_diff = predicted_age - actual_age
if age_diff < 0:
age_diff = 0 # we should not see negative, treat all negative as model didn't do anything.
negative_count += 1
age_diffs.append(age_diff)
print('Max Age Progression: {:.2f}'.format(max(age_diffs)))
print('Avg Age Progression: {:.2f}'.format(
sum(age_diffs) / len(age_diffs)))
print('10+ Age Progression: {:.2f}%'.format(
len([x for x in age_diffs if x >= 10]) / len(age_diffs) * 100))
print('15+ Age Progression: {:.2f}%'.format(
len([x for x in age_diffs if x >= 15]) / len(age_diffs) * 100))
print('20+ Age Progression: {:.2f}%'.format(
len([x for x in age_diffs if x >= 20]) / len(age_diffs) * 100))
print('Neg Age Progression: {:d} out of {:d}'.format(
negative_count, len(age_diffs)))
from keras.preprocessing import image
# Flask utils
from flask import Flask, redirect, url_for, request, render_template
from werkzeug.utils import secure_filename
from gevent.pywsgi import WSGIServer
from wide_resnet import WideResNet
app = Flask(__name__)
MODEL_PATH = 'models/xxx.hdf5'
img_size = 64
model = load_model(MODEL_PATH)
model = WideResNet(img_size, depth=16, k=8)()
model.load_weights(MODEL_PATH)
print('Model loaded. Start serving...')
def model_predict(img_path, model):
img = cv2.imread(img_path)
img = cv2.resize(img, (64, 64))
img = np.expand_dims(img, 0)
# predict
results = model.predict(img)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
predicted_ages = str(int(predicted_ages.item(0)))
if predicted_genders.item(0) > 0.5:
def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
if not weight_file:
weight_file = os.path.join("pretrained_models", "weights.18-4.06.hdf5")
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
# capture video
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
while True:
# get video frame
ret, img = cap.read()
if not ret:
print("error: failed to capture image")
return -1
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(
), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - 0.4 * w), 0)
yw1 = max(int(y1 - 0.4 * h), 0)
xw2 = min(int(x2 + 0.4 * w), img_w - 1)
yw2 = min(int(y2 + 0.4 * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1, :],
(img_size, img_size))
if len(detected) > 0:
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, d in enumerate(detected):
label = "{}, {}".format(
int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M")
draw_label(img, (d.left(), d.top()), label)
#print(label)
#print(get_face_encodings(input_img, detected))
#faces = get_face_encodings(input_img, detected)
#if not compare_face_encodings(faces):
# print("new face")
# known_faces.append(faces)
cv2.imshow("result", img)
key = cv2.waitKey(30)
if key == 27:
break
def main():
socket = SocketIO('localhost', 3002, LoggingNamespace)
print("connect")
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
margin = args.margin
image_dir = args.image_dir
if not weight_file:
weight_file = get_file("checkpoints/weights.78-3.51.hdf5",
pretrained_model,
cache_subdir="pretrained_models",
file_hash=modhash,
cache_dir=Path(__file__).resolve().parent)
# for face detection
detector = dlib.get_frontal_face_detector()
# age and gender
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
age_list = []
image_generator = yield_images_from_dir(
image_dir) if image_dir else yield_images()
for img in image_generator:
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
if len(detected) > 0:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(
), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - margin * w), 0)
yw1 = max(int(y1 - margin * h), 0)
xw2 = min(int(x2 + margin * w), img_w - 1)
yw2 = min(int(y2 + margin * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(
img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
emotion = get_emotion(imgNum)
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
print(int(predicted_ages))
print(predicted_genders)
print(emotion)
print()
file = './thumbnail0.jpg'
if os.path.isfile(file):
os.remove(file)
age_list.append(int(predicted_ages))
if len(age_list) == 2:
predicted_ages_final = (age_list[0] + age_list[1]) / 2
print(int(predicted_ages_final))
age_list = []
crawling = bsObject.body.find_all("em")[2].get_text()
crawling_num = re.findall("\d+", crawling)
crawling_dust = bsObject.body.find_all("strong")[3].get_text()
crawling_text = bsObject.body.find_all("em")[3].get_text()
for i, d in enumerate(detected):
label = "{},{},{},{},{},{}".format(
int(predicted_ages_final),
"f" if predicted_genders[i][0] < 0.6 else "m",
"neutral" if emotion is None else emotion[2][0],
crawling_num[0], crawling_dust, crawling_text)
listA = label.split(",")
print(listA)
socket.emit('client1', listA)
while True:
# sleep(0.5)
# Listen
socket.on('finish', on_finish)
socket.wait(seconds=1)
global flag
if flag is True:
flag = False
break
# 웹캠 실행 시
key = cv2.waitKey(-1) if image_dir else cv2.waitKey(30)
if key == 27: # ESC
break
def main():
args = get_args()
depth = args.depth
k = args.width
# weight_file = args.weight_file
weight_file = "checkpoints168/weights.48-3.62.hdf5"
margin = args.margin
image_dir = args.image_dir
if not weight_file:
weight_file = get_file("weights.28-3.73.hdf5",
pretrained_model,
cache_subdir="pretrained_models",
file_hash=modhash,
cache_dir=str(Path(__file__).resolve().parent))
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
image_generator = yield_images_from_dir(
image_dir) if image_dir else yield_images()
# image_generator=yield_images()
skip_frame = 1
ind = 0
for img_ in image_generator:
print(img_.shape)
if ind % skip_frame == 0:
bounding_boxes = detect_face(img_)
print("face number: ", len(bounding_boxes))
faces = np.empty((len(bounding_boxes), 64, 64, 3))
for i, bounding_box in enumerate(bounding_boxes):
x = int(bounding_box[0])
y = int(bounding_box[1])
w = int(bounding_box[2])
h = int(bounding_box[3])
img_h, img_w, _ = np.shape(img_)
_x = max(int(x - margin * w), 0)
_y = max(int(y - margin * h), 0)
_x2 = min(int(x + w + margin * w), img_w - 1)
_y2 = min(int(y + h + margin * h), img_h - 1)
cv2.rectangle(img_, (x, y), (x + w, y + h), (0, 155, 255), 2)
cv2.rectangle(img_, (_x, _y), (_x2, _y2), (255, 155, 255), 2)
faces[i, :, :, :] = cv2.resize(img_[_y:_y2 + 1, _x:_x2 + 1, :],
(64, 64))
# predict ages and genders of the detected facesƯ
try:
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, bounding_box in enumerate(bounding_boxes):
label = "{}, {}".format(
int(predicted_ages[i]),
"Nam" if predicted_genders[i][0] < 0.5 else "Nữ")
draw_label(img_,
(int(bounding_box[0]), int(bounding_box[1])),
label)
cv2.imshow("result", img_)
# cv2.waitKey(0)
# print(ind)
key = cv2.waitKey(-1) if image_dir else cv2.waitKey(30)
if key == 27: # ESC
break
continue
except:
cv2.imshow("result", img_)
key = cv2.waitKey(-1) if image_dir else cv2.waitKey(30)
if key == 27: # ESC
break
ind = ind + 1
def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
margin = args.margin
image_dir = args.image_dir
if not weight_file:
weight_file = get_file("weights.28-3.73.hdf5",
pretrained_model,
cache_subdir="pretrained_models",
file_hash=modhash,
cache_dir=str(Path(__file__).resolve().parent))
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
image_generator = yield_images_from_dir(
image_dir) if image_dir else yield_images()
for img in image_generator:
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
if len(detected) > 0:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(
), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - margin * w), 0)
yw1 = max(int(y1 - margin * h), 0)
xw2 = min(int(x2 + margin * w), img_w - 1)
yw2 = min(int(y2 + margin * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(
img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, d in enumerate(detected):
label = "{}, {}".format(
int(predicted_ages[i]),
"M" if predicted_genders[i][0] < 0.5 else "F")
draw_label(img, (d.left(), d.top()), label)
cv2.imshow("result", img)
key = cv2.waitKey(-1) if image_dir else cv2.waitKey(30)
if key == 27: # ESC
break
def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
if not weight_file:
weight_file = os.path.join("pretrained_models", "weights.18-4.06.hdf5")
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
# capture video
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
while True:
# get video frame
ret, img = cap.read()
if not ret:
print("error: failed to capture image")
return -1
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - 0.4 * w), 0)
yw1 = max(int(y1 - 0.4 * h), 0)
xw2 = min(int(x2 + 0.4 * w), img_w - 1)
yw2 = min(int(y2 + 0.4 * h), img_h - 1)
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[i,:,:,:] = cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
if len(detected) > 0:
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, d in enumerate(detected):
label = "{}, {}".format(int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M")
draw_label(img, (d.left(), d.top()), label)
cv2.imshow("result", img)
key = cv2.waitKey(30)
if key == 27:
break
class FaceCV(object):
"""
Singleton class for face recongnition task
"""
CASE_PATH = ".\\pretrained_models\\haarcascade_frontalface_alt.xml"
WRN_WEIGHTS_PATH = "https://github.com/Tony607/Keras_age_gender/releases/download/V1.0/weights.18-4.06.hdf5"
def __new__(cls, weight_file=None, depth=16, width=8, face_size=64):
if not hasattr(cls, 'instance'):
cls.instance = super(FaceCV, cls).__new__(cls)
return cls.instance
def __init__(self, depth=16, width=8, face_size=64):
self.face_size = face_size
self.model = WideResNet(face_size, depth=depth, k=width)()
model_dir = os.path.join(os.getcwd(),
"pretrained_models").replace("//", "\\")
fpath = get_file('weights.18-4.06.hdf5',
self.WRN_WEIGHTS_PATH,
cache_subdir=model_dir)
self.model.load_weights(fpath)
@classmethod
def draw_label(cls,
image,
point,
label,
font=cv2.FONT_HERSHEY_SIMPLEX,
font_scale=1,
thickness=2):
size = cv2.getTextSize(label, font, font_scale, thickness)[0]
x, y = point
cv2.rectangle(image, (x, y - size[1]), (x + size[0], y), (255, 0, 0),
cv2.FILLED)
cv2.putText(image, label, point, font, font_scale, (255, 255, 255),
thickness)
def crop_face(self, imgarray, section, margin=40, size=64):
"""
:param imgarray: full image
:param section: face detected area (x, y, w, h)
:param margin: add some margin to the face detected area to include a full head
:param size: the result image resolution with be (size x size)
:return: resized image in numpy array with shape (size x size x 3)
"""
img_h, img_w, _ = imgarray.shape
if section is None:
section = [0, 0, img_w, img_h]
(x, y, w, h) = section
margin = int(min(w, h) * margin / 100)
x_a = x - margin
y_a = y - margin
x_b = x + w + margin
y_b = y + h + margin
if x_a < 0:
x_b = min(x_b - x_a, img_w - 1)
x_a = 0
if y_a < 0:
y_b = min(y_b - y_a, img_h - 1)
y_a = 0
if x_b > img_w:
x_a = max(x_a - (x_b - img_w), 0)
x_b = img_w
if y_b > img_h:
y_a = max(y_a - (y_b - img_h), 0)
y_b = img_h
cropped = imgarray[y_a:y_b, x_a:x_b]
resized_img = cv2.resize(cropped, (size, size),
interpolation=cv2.INTER_AREA)
resized_img = np.array(resized_img)
return resized_img, (x_a, y_a, x_b - x_a, y_b - y_a)
def detect_face(self):
face_cascade = cv2.CascadeClassifier(self.CASE_PATH)
# 0 means the default video capture device in OS
video_capture = cv2.VideoCapture(0)
# infinite loop, break by key ESC
while True:
if not video_capture.isOpened():
sleep(5)
# Capture frame-by-frame
ret, frame = video_capture.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray,
scaleFactor=1.2,
minNeighbors=10,
minSize=(self.face_size,
self.face_size))
# placeholder for cropped faces
face_imgs = np.empty(
(len(faces), self.face_size, self.face_size, 3))
for i, face in enumerate(faces):
face_img, cropped = self.crop_face(frame,
face,
margin=40,
size=self.face_size)
(x, y, w, h) = cropped
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 200, 0), 2)
face_imgs[i, :, :, :] = face_img
if len(face_imgs) > 0:
# predict ages and genders of the detected faces
results = self.model.predict(face_imgs)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, face in enumerate(faces):
label = "{}, {}".format(
int(predicted_ages[i]),
"F" if predicted_genders[i][0] > 0.5 else "M")
self.draw_label(frame, (face[0], face[1]), label)
cv2.imshow('Keras Faces', frame)
if cv2.waitKey(5) == 27: # ESC key press
break
# When everything is done, release the capture
video_capture.release()
cv2.destroyAllWindows()
from wide_resnet import WideResNet
from keras.models import load_model
from keras.preprocessing import image
from keras.applications.inception_v3 import InceptionV3
from keras.layers import Dense, GlobalAveragePooling2D, Dropout
from keras.utils.training_utils import multi_gpu_model
from keras.models import Model
from utilities import *
# Constants
gender_img_size = 64
predict_img_size = 256
# Loading models
gender_model = WideResNet(gender_img_size, depth=16, k=8)()
gender_model.load_weights(
os.path.join("pretrained weights", "weights.18-4.06.hdf5"))
print("Gender models loaded.")
female_base_model = InceptionV3(weights='imagenet',
include_top=False,
input_shape=(predict_img_size,
predict_img_size, 3))
male_base_model = InceptionV3(weights='imagenet',
include_top=False,
input_shape=(predict_img_size, predict_img_size,
3))
print("Base models loaded.")
x_female = female_base_model.output
x_female = GlobalAveragePooling2D()(x_female)
x_female = Dense(1024, activation='relu')(x_female)
"""
Created by Alex Wang
On 2018-06-26
"F" if predicted_genders[i][0] > 0.5 else "M"
"""
import os
import traceback
import time
import numpy as np
import cv2
from wide_resnet import WideResNet
face_size = 64
model = WideResNet(face_size, depth=16, k=8)()
model.load_weights('weights.18-4.06.hdf5')
def test_one(image_path):
try:
face_cascade = cv2.CascadeClassifier(
'haarcascades/haarcascade_frontalface_alt.xml')
img_org = cv2.imread(image_path)
height, width = img_org.shape[0:2]
img_gray = cv2.cvtColor(img_org, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(img_gray, 1.1, 3)
for (x, y, w, h) in faces:
up_margin = w / 3
margin = w / 4
y_min = max(0, y - up_margin)
def main():
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
margin = args.margin
image_dir = args.image_dir
if not weight_file:
weight_file = get_file("weights.28-3.73.hdf5",
pretrained_model,
cache_subdir="pretrained_models",
file_hash=modhash,
cache_dir=Path(__file__).resolve().parent)
# for face detection
detector = dlib.get_frontal_face_detector()
MODEL_NAME = 'ssd_inception_v2_coco_2017_11_17'
MODEL_FILE = MODEL_NAME + '.tar.gz'
DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'
# Path to frozen detection graph. This is the actual model that is used for the object detection.
PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'
# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')
# Number of classes to detect
NUM_CLASSES = 90
# Download Model
opener = urllib.request.URLopener()
opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)
tar_file = tarfile.open(MODEL_FILE)
for file in tar_file.getmembers():
file_name = os.path.basename(file.name)
if 'frozen_inference_graph.pb' in file_name:
tar_file.extract(file, os.getcwd())
# Load a (frozen) Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
# Loading label map
# Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`. Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Extract detection boxes
boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Extract detection scores
scores = detection_graph.get_tensor_by_name('detection_scores:0')
# Extract detection classes
classes = detection_graph.get_tensor_by_name('detection_classes:0')
# Extract number of detectionsd
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
# load model and weights
img_size = 64
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
emotion_model_path = './pretrained_models/fer2013_mini_XCEPTION.102-0.66.hdf5'
emotion_classifier = load_model(emotion_model_path, compile=False)
emotion_target_size = emotion_classifier.input_shape[1:3]
emotion_offsets = (20, 40)
emotion_labels = get_labels('fer2013')
image_generator = yield_images_from_dir(
image_dir) if image_dir else yield_images()
cv2.namedWindow("result", cv2.WINDOW_NORMAL)
for img in image_generator:
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
image_object = np.expand_dims(img, axis=0)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Extract detection boxes
boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Extract detection scores
scores = detection_graph.get_tensor_by_name('detection_scores:0')
# Extract detection classes
classes = detection_graph.get_tensor_by_name('detection_classes:0')
# Extract number of detectionsd
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
# Actual detection.
(boxes, scores, classes,
num_detections) = sess.run([boxes, scores, classes, num_detections],
feed_dict={image_tensor: image_object})
if len(detected) > 0:
vis_util.visualize_boxes_and_labels_on_image_array(
img,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8)
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(
), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - margin * w), 0)
yw1 = max(int(y1 - margin * h), 0)
xw2 = min(int(x2 + margin * w), img_w - 1)
yw2 = min(int(y2 + margin * h), img_h - 1)
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(
img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
# predict ages and genders of the detected faces
results = model.predict(faces)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# draw results
for i, d in enumerate(detected):
face_coordinates = make_face_coordinates(d)
x1, x2, y1, y2 = apply_offsets(face_coordinates,
emotion_offsets)
gray_face = gray_image[y1:y2, x1:x2]
try:
gray_face = cv2.resize(gray_face, (emotion_target_size))
except:
continue
gray_face = preprocess_input(gray_face, False)
gray_face = np.expand_dims(gray_face, 0)
gray_face = np.expand_dims(gray_face, -1)
emotion_label_arg = np.argmax(
emotion_classifier.predict(gray_face))
emotion_text = emotion_labels[emotion_label_arg]
label = emotion_text + " {}, {}".format(
int(predicted_ages[i] - 4),
"F" if predicted_genders[i][0] > 0.5 else "M")
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
draw_label(img, (d.left(), d.top()), label)
cv2.imshow("result", img)
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
class FaceCV(object):
CASE_PATH = "./pretrained_models/haarcascade_frontalface_alt.xml"
WRN_WEIGHTS_PATH = "https://github.com/iamshreeram/human-gender-detection/releases/download/1.0/weights.hdf5"
def __new__(cls, weight_file=None, depth=16, width=8, face_size=64):
if not hasattr(cls, 'instance'):
cls.instance = super(FaceCV, cls).__new__(cls)
return cls.instance
def __init__(self, depth=16, width=8, face_size=64):
self.face_size = face_size
self.model = WideResNet(face_size, depth=depth, k=width)()
model_dir = os.path.join(os.getcwd(), "pretrained_models").replace("//", "\\")
fpath = get_file('weights.hdf5',self.WRN_WEIGHTS_PATH,cache_subdir=model_dir)
self.model.load_weights(fpath)
@classmethod
def draw_label(cls, image, point, label, font=cv2.FONT_HERSHEY_SIMPLEX,
font_scale=1, thickness=2):
size = cv2.getTextSize(label, font, font_scale, thickness)[0]
x, y = point
cv2.rectangle(image, (x, y - size[1]), (x + size[0], y), (0, 255, 0), cv2.FILLED)
cv2.putText(image, label, point, font, font_scale, (255, 255, 255), thickness)
def crop_face(self, imgarray, section, margin=40, size=64):
"""
:param imgarray: full image
:param section: face detected area (x, y, w, h)
:param margin: add some margin to the face detected area to include a full head
:param size: the result image resolution with be (size x size)
:return: resized image in numpy array with shape (size x size x 3)
"""
img_h, img_w, _ = imgarray.shape
if section is None:
section = [0, 0, img_w, img_h]
(x, y, w, h) = section
margin = int(min(w,h) * margin / 100)
x_a = x - margin
y_a = y - margin
x_b = x + w + margin
y_b = y + h + margin
if x_a < 0:
x_b = min(x_b - x_a, img_w-1)
x_a = 0
if y_a < 0:
y_b = min(y_b - y_a, img_h-1)
y_a = 0
if x_b > img_w:
x_a = max(x_a - (x_b - img_w), 0)
x_b = img_w
if y_b > img_h:
y_a = max(y_a - (y_b - img_h), 0)
y_b = img_h
cropped = imgarray[y_a: y_b, x_a: x_b]
resized_img = cv2.resize(cropped, (size, size), interpolation=cv2.INTER_AREA)
resized_img = np.array(resized_img)
return resized_img, (x_a, y_a, x_b - x_a, y_b - y_a)
def detect_face(self):
face_cascade = cv2.CascadeClassifier(self.CASE_PATH)
# 0 means the default video capture device in OS
video_capture = cv2.VideoCapture(-1)
# infinite loop, break by key ESC
while True:
if not video_capture.isOpened():
sleep(5)
# Capture frame-by-frame
ret, frame = video_capture.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
print(face_cascade)
faces = face_cascade.detectMultiScale(
gray,
scaleFactor=1.2,
minNeighbors=10,
minSize=(self.face_size, self.face_size)
)
# placeholder for cropped faces
face_imgs = np.empty((len(faces), self.face_size, self.face_size, 3))
for i, face in enumerate(faces):
face_img, cropped = self.crop_face(frame, face, margin=40, size=self.face_size)
(x, y, w, h) = cropped
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 200, 0), 2)
face_imgs[i,:,:,:] = face_img
if len(face_imgs) > 0:
# predict ages and genders of the detected faces
results = self.model.predict(face_imgs)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
# draw results
for i, face in enumerate(faces):
# label = "{}, {}".format(int(predicted_ages[i]),"F" if predicted_genders[i][0] > 0.5 else "M")
# self.draw_label(frame, (face[0], face[1]), label)
label = "{}".format("Female" if predicted_genders[i][0] > 0.5 else "Male")
self.draw_label(frame, (face[0], face[1]), label)
cv2.imshow('Gender Detector Engine', frame)
if cv2.waitKey(5) == 27: # ESC key press
break
# When everything is done, release the capture
video_capture.release()
cv2.destroyAllWindows()
def run(self):
args = get_args()
depth = args.depth
k = args.width
weight_file = args.weight_file
if not weight_file:
weight_file = get_file("weights.18-4.06.hdf5", pretrained_model, cache_subdir="pretrained_models",
file_hash=modhash, cache_dir=os.path.dirname(os.path.abspath(__file__)))
# for face detection
detector = dlib.get_frontal_face_detector()
# load model and weights
img_size = 64
index_image = 0
model = WideResNet(img_size, depth=depth, k=k)()
model.load_weights(weight_file)
# list = os.listdir(pathToDirectory)
photoN = '\\image' + str(index_image) + '.jpg'
numOfPerson=0
while True :
time.sleep(5)
list = os.listdir(pathToDirectory)
print("scan...")
if len(list) != numOfPerson:
Index.Nmb_of_people=0
Index.age_tot = 0
Index.count_of_men=0
Index.count_of_women=0
#get the pictures of the persons from the directory
for person in list:
Index.Nmb_of_people+=1
#the adress of one picture
name1 = pathToDirectory + person + photoN
print(person)
if os.path.exists(name1):
img = imread(name1)
input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_h, img_w, _ = np.shape(input_img)
# detect faces using dlib detector
detected = detector(input_img, 1)
faces = np.empty((len(detected), img_size, img_size, 3))
if len(detected) > 0:
for i, d in enumerate(detected):
x1, y1, x2, y2, w, h = d.left(), d.top(), d.right() + 1, d.bottom() + 1, d.width(), d.height()
xw1 = max(int(x1 - 0.4 * w), 0)
yw1 = max(int(y1 - 0.4 * h), 0)
xw2 = min(int(x2 + 0.4 * w), img_w - 1)
yw2 = min(int(y2 + 0.4 * h), img_h - 1)
# cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2) ##change la valeur je ne sais pas pourquoi
# cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)
faces[i, :, :, :] = cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))
# predict ages and genders of the detected faces####################################################################################################################
results = model.predict(faces) ##contien les deux resultats (sexe et age)
######get the gender predicted from the model
predicted_genders = results[0]
gender = "F" if predicted_genders[i][0] > 0.5 else "M"
print(gender) # imprime le sexe
if gender == "M":
Index.count_of_men+=1
else :
Index.count_of_women+=1
####get the age predicted from the model
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
age = round(predicted_ages[0], 0)
print(age) # imprime l age
print("images/"+person+".jpg")
print(name1)
Index.age_tot+=age
##all this code is used to upload the new datas into the databases
pyrUp= storage1.child("images/"+person+".jpg").put(name1, user['idToken'])
picUrl = storage1.child("images/"+person+".jpg").get_url(pyrUp['downloadTokens'])
time1 = datetime.datetime.now().time()
data = {"DisplayLabel": "Age", "identifier": "text", "showHideLabel" : "1","showInListing" : "1" ,"value" : str(age) }
db.child("person").child(person).child("Age").set(data)
data = {"DisplayLabel": "Gender", "identifier": "text", "showHideLabel": "1",
"showInListing": "1", "value": gender}
db.child("person").child(person).child("Gender").set(data)
data = {"DisplayLabel": "Picture", "identifier": "file", "showHideLabel": "1",
"showInListing": "1", "value": str(picUrl)}
db.child("person").child(person).child("Picture").set(data)
data = {"DisplayLabel": "Time", "identifier": "text", "showHideLabel": "1",
"showInListing": "1",
"value": str(time1)}
db.child("person").child(person).child("Number Of People").set(data)
if not os.path.isfile(pathToDirectory + '\\' + person + '\\predicted.txt'):
f = open(pathToDirectory + '\\' + person + '\\predicted.txt', 'w')
f.write('gender = ' + gender + ' age = ' + str(age))
f.close()
data = {"DisplayLabel": "People", "identifier": "text", "showHideLabel": "1",
"showInListing": "1", "value": "Total : "+str(Index.Nmb_of_people)+" => Women: "+str(Index.count_of_women)+" Men: "+str(Index.count_of_men)}
db.child("person").child("person0").child("Number Of People").set(data)
AVG_age = Index.age_tot/Index.Nmb_of_people
data = {"DisplayLabel": ".......Age AVG", "identifier": "text", "showHideLabel": "1",
"showInListing": "1", "value": AVG_age}
db.child("person").child("person0").child("Age").set(data)
# cv2.imshow("result", img) # affiche le resultat a l'ecran (facultatif)
numOfPerson = len(list)
pass
