# pip install deepface import cv2 from deepface import DeepFace import numpy as np imgpath = "D:\\1.program\\python\\python2\\python-practise\\I know python\\how to with python\\Real time emotion detection\\1.jpg" image = cv2.imread(imgpath) analyze = DeepFace.analyze(image, actions=['emotion']) print(analyze)
import tensorflow as tf from PIL import Image from io import BytesIO from deepface import DeepFace with open("main/test_image.png", "rb") as image: f = image.read() b = bytearray(f) img = Image.open(BytesIO(b)) image_array = tf.keras.preprocessing.image.img_to_array(img) # demography = DeepFace.analyze(image_array, actions=["emotion"]) demography = DeepFace.analyze(image_array, actions=["age", "gender", "race", "emotion"]) result = DeepFace.verify(image_array, image_array, model_name="Facenet") print("Is verified: ", result["verified"])
def analyze_face_image(image_path): obj = DeepFace.analyze(image_path, actions=['age', 'gender', 'race', 'emotion']) print(obj["age"], " years old ", obj["dominant_race"], " ", obj["dominant_emotion"], " ", obj["dominant_gender"])
import logging tf.get_logger().setLevel(logging.ERROR) print("Running unit tests for TF ", tf.__version__) #----------------------------------------- dataset = [['dataset/img1.jpg', 'dataset/img2.jpg', True], ['dataset/img1.jpg', 'dataset/img6.jpg', True]] print("-----------------------------------------") print("Face detectors test") print("ssd detector") res = DeepFace.verify(dataset, detector_backend='ssd') print(res) print("opencv detector") res = DeepFace.verify(dataset, detector_backend='opencv') print(res) print("dlib detector") res = DeepFace.verify(dataset, detector_backend='dlib') print(res) print("mtcnn detector") res = DeepFace.verify(dataset, detector_backend='mtcnn') print(res) print("-----------------------------------------")
pretrained_models["DeepFace"] = FbDeepFace.loadModel() print("FbDeepFace loaded") pretrained_models["DeepID"] = DeepID.loadModel() print("DeepID loaded") instances = df[["file_x", "file_y"]].values.tolist() models = ['VGG-Face'] metrics = ["cosine"] if True: for model in models: for metric in metrics: resp_obj = DeepFace.verify(instances, model_name=model, model=pretrained_models[model], distance_metric=metric) distances = [] for i in range(0, len(instances)): distance = round(resp_obj["pair_%s" % (i + 1)]["distance"], 4) distances.append(distance) df['%s_%s' % (model, metric)] = distances df.to_csv("face-recognition-pivot.csv", index=False) else: df = pd.read_csv("face-recognition-pivot.csv") df_raw = df.copy()
# Save output of the function. filename = output_name.format(os.getpid()) cv2.imwrite(filename, processed_img) # Check the output of face_detect function. img_path = '/content/drive/My Drive/IMG_20201007_200043.jpg' output_name = 'pan_img.jpg' pan = face_detect(img_path, output_name) # Check the output of face_detect function. img_path = '/content/drive/My Drive/IMG20201010221637.jpg' output_name = 'clicked_img.jpg' orig = face_detect(img_path, output_name) #### Resize the image because output of face_detect func will be scaled according #### to original image but for verification size of both the images should be #### same(PAN card image is little squeezed, resizing will solve that issue). def resize_img(path, size): img = cv2.imread(path) img = cv2.resize(img, (size, size)) return img clicked_img = resize_img('/content/clicked_img.jpg', 512) pan_img = resize_img('/content/pan_img.jpg', 512) # Set enforce_detection False: Face could not be detected. Please confirm that the picture # is a face photo or consider to set enforce_detection param to False. result = DeepFace.verify(clicked_img, pan_img, enforce_detection = False) print("Is verified: ", result["verified"])
app = Flask(__name__) #------------------------------ tic = time.time() print("Loading Face Recognition Models...") pbar = tqdm(range(0, 6), desc='Loading Face Recognition Models...') for index in pbar: if index == 0: pbar.set_description("Loading VGG-Face") vggface_model = DeepFace.build_model("VGG-Face") elif index == 1: pbar.set_description("Loading OpenFace") openface_model = DeepFace.build_model("OpenFace") elif index == 2: pbar.set_description("Loading Google FaceNet") facenet_model = DeepFace.build_model("Facenet") elif index == 3: pbar.set_description("Loading Facebook DeepFace") deepface_model = DeepFace.build_model("DeepFace") elif index == 4: pbar.set_description("Loading DeepID DeepFace") deepid_model = DeepFace.build_model("DeepID") elif index == 5: pbar.set_description("Loading ArcFace DeepFace") arcface_model = DeepFace.build_model("ArcFace")
#! /usr/bin/python3 from deepface import DeepFace import time tik = time.time() result = DeepFace.verify("katya1.jpg", "katya2.jpg", model_name='ArcFace', detector_backend='retinaface') # 'retinaface' print("Is verified: ", result["verified"], time.time() - tik)
from deepface import DeepFace # result = DeepFace.stream("face_images/Trump/4.jpg") result = DeepFace.stream("face_images/Gates/1.jpg")
#detect your emotions via webcam realtime using deepface library import cv2 import matplotlib.pyplot as plt from deepface import DeepFace #download preatrained CNN weights -> https://drive.google.com/uc?id=1YCox_4kJ-BYeXq27uUbasu--yz28zUMV # save .h5 at 'C:\Users\Steven_Verkest/.deepface/weights/age_model_weights.h5' faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascades.xml') cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() #read one image from a video (1 frame) result = DeepFace.analyze(frame, actions=['emotion']) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale(gray, 1.1, 4) # draw rectangle around the face for (x, y, w, h) in faces: cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2) # draw text font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(frame, result['dominant_emotion'], (50, 50), font, 3, (0, 255, 0), 2, cv2.LINE_4) cv2.imshow('original video', frame) if cv2.waitKey(2) & 0xff == ord('q'): break
from deepface import DeepFace result = DeepFace.verify( r"C:\Users\bitcamp\Desktop\opencv_dnn_202005\image\ujung.jpg") print("Is verified: ", result["verified"]) print()
def test_cases(): print("DeepFace.detectFace test") for detector in detectors: img = DeepFace.detectFace("dataset/img11.jpg", detector_backend=detector) evaluate(img.shape[0] > 0 and img.shape[1] > 0) print(detector, " test is done") print("-----------------------------------------") img_path = "dataset/img1.jpg" embedding = DeepFace.represent(img_path) print("Function returned ", len(embedding), "dimensional vector") evaluate(len(embedding) > 0) print("-----------------------------------------") print("Face detectors test") for detector in detectors: print(detector + " detector") res = DeepFace.verify(dataset[0][0], dataset[0][1], detector_backend=detector) print(res) assert res["verified"] == dataset[0][2] print("-----------------------------------------") print("Find function test") df = DeepFace.find(img_path="dataset/img1.jpg", db_path="dataset") print(df.head()) evaluate(df.shape[0] > 0) print("-----------------------------------------") print("Facial analysis test. Passing nothing as an action") img = "dataset/img4.jpg" demography = DeepFace.analyze(img) print(demography) evaluate(demography["age"] > 20 and demography["age"] < 40) evaluate(demography["dominant_gender"] == "Woman") print("-----------------------------------------") print("Facial analysis test. Passing all to the action") demography = DeepFace.analyze(img, ['age', 'gender', 'race', 'emotion']) print("Demography:") print(demography) #check response is a valid json print("Age: ", demography["age"]) print("Gender: ", demography["dominant_gender"]) print("Race: ", demography["dominant_race"]) print("Emotion: ", demography["dominant_emotion"]) evaluate(demography.get("age") is not None) evaluate(demography.get("dominant_gender") is not None) evaluate(demography.get("dominant_race") is not None) evaluate(demography.get("dominant_emotion") is not None) print("-----------------------------------------") print( "Facial analysis test 2. Remove some actions and check they are not computed" ) demography = DeepFace.analyze(img, ['age', 'gender']) print("Age: ", demography.get("age")) print("Gender: ", demography.get("dominant_gender")) print("Race: ", demography.get("dominant_race")) print("Emotion: ", demography.get("dominant_emotion")) evaluate(demography.get("age") is not None) evaluate(demography.get("dominant_gender") is not None) evaluate(demography.get("dominant_race") is None) evaluate(demography.get("dominant_emotion") is None) print("-----------------------------------------") print("Facial recognition tests") for model in models: for metric in metrics: for instance in dataset: img1 = instance[0] img2 = instance[1] result = instance[2] resp_obj = DeepFace.verify(img1, img2, model_name=model, distance_metric=metric) prediction = resp_obj["verified"] distance = round(resp_obj["distance"], 2) threshold = resp_obj["threshold"] passed = prediction == result evaluate(passed) if passed: test_result_label = "passed" else: test_result_label = "failed" if prediction == True: classified_label = "verified" else: classified_label = "unverified" print( img1.split("/")[-1], "-", img2.split("/")[-1], classified_label, "as same person based on", model, "and", metric, ". Distance:", distance, ", Threshold:", threshold, "(", test_result_label, ")") print("--------------------------") # ----------------------------------------- print("Passing numpy array to analyze function") img = cv2.imread("dataset/img1.jpg") resp_obj = DeepFace.analyze(img) print(resp_obj) evaluate(resp_obj["age"] > 20 and resp_obj["age"] < 40) evaluate(resp_obj["gender"] == "Woman") print("--------------------------") print("Passing numpy array to verify function") img1 = cv2.imread("dataset/img1.jpg") img2 = cv2.imread("dataset/img2.jpg") res = DeepFace.verify(img1, img2) print(res) evaluate(res["verified"] == True) print("--------------------------") print("Passing numpy array to find function") img1 = cv2.imread("dataset/img1.jpg") df = DeepFace.find(img1, db_path="dataset") print(df.head()) evaluate(df.shape[0] > 0) print("--------------------------") print("non-binary gender tests") #interface validation - no need to call evaluate here for img1_path, img2_path, verified in dataset: for detector in detectors: result = DeepFace.analyze(img1_path, actions=('gender', ), detector_backend=detector, enforce_detection=False) print(result) assert 'gender' in result.keys() assert 'dominant_gender' in result.keys( ) and result["dominant_gender"] in ["Man", "Woman"] if result["dominant_gender"] == "Man": assert result["gender"]["Man"] > result["gender"]["Woman"] else: assert result["gender"]["Man"] < result["gender"]["Woman"]
import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #----------------------------------------- print("Bulk tests") print("-----------------------------------------") print("Bulk face recognition tests") dataset = [['dataset/img1.jpg', 'dataset/img2.jpg', True], ['dataset/img5.jpg', 'dataset/img6.jpg', True]] resp_obj = DeepFace.verify(dataset) print(resp_obj["pair_1"]["verified"] == True) print(resp_obj["pair_2"]["verified"] == True) print("-----------------------------------------") print("Bulk facial analysis tests") dataset = [ 'dataset/img1.jpg', 'dataset/img2.jpg', 'dataset/img5.jpg', 'dataset/img6.jpg' ] resp_obj = DeepFace.analyze(dataset) print(resp_obj["instance_1"]["age"], " years old ", resp_obj["instance_1"]["dominant_emotion"], " ",
from deepface import DeepFace result = DeepFace.verify("face_images/Gates/1.jpg", "face_images/Gates/2.jpg") print(result)
# resize pixels to the model size face_image = Image.fromarray(face_boundary) face_image = face_image.resize(required_size) face_array = asarray(face_image) face_images.append(face_array) return face_images extracted_face = extract_face_from_image('kaushiki2.jpg') #Display the face from the extracted faces plt.imshow(extracted_face[0]) plt.show() #Compare the single/Multiple faces in two images from deepface import DeepFace import cv2 from matplotlib import pyplot as plt img1 = cv2.imread("women.jpg") plt.imshow(img1[:, :, ::-1]) plt.show() img2 = cv2.imread("5 women.jpg") plt.imshow(img2[:, :, ::-1]) plt.show() result = DeepFace.verify(img1, img2) print("Is same face", result["verified"])
from deepface import DeepFace nCustomers = 0 nMale = 0 nFemale = 0 nHappy = 0 nSad = 0 #taking image input image_path = [ 'image1.jpeg', 'image2.jpeg', 'image3.jpeg', 'image4.jpeg', 'image5.jpeg', 'image6.jpeg' ] for imgPath in image_path: data = DeepFace.analyze(imgPath) if (data["gender"] == 'Man'): nMale += 1 elif (data["gender"] == 'Woman'): nFemale += 1 if (data["dominant_emotion"] == 'happy'): nHappy += 1 elif (data["dominant_emotion"] == 'sad'): nSad += 1 nCustomers += 1 print("\nNumber of customers visited:", nCustomers) print("Number of males customer:", nMale) print("Number of females customer:", nFemale) print("Number of happy customer:", nHappy)
from deepface import DeepFace import os import cv2 img1_path = 'image/ping_1.png' img2_path = 'image/Oak_3.png' img_1 = cv2.imread(img1_path) img_2 = cv2.imread(img2_path) result = DeepFace.verify(img1_path, img2_path, model_name = 'ArcFace') print(result)
auto_size_text=True, font='helvetica', element_justification='center', icon=icon_logo64).Layout(layout) # Event Loop while True: event, values = window.Read() if event in (None, 'Exit'): break if event == 'Submit': # Update the "output" text element to be the value of "input" element window['-OUTPUT-'].update(values['-INPUT-']) elif event == 'Start Human Emotion Detection': DeepFace.stream("DATABASE") text_input = values['-INPUT-'] elif event == "Upload Subject's Image": sg.popup_get_file('Select Image:', "Upload Subject's Image", icon=icon_logo64) elif event == 'Onboard Subject': text_input = values['-INPUT-'] subject_onboarding(text_input) # Close Window window.Close()
from deepface import DeepFace obj = DeepFace.analyze(r"static\uploads\sai_3.jpg") print(type(obj)) #objs = DeepFace.analyze(["img1.jpg", "img2.jpg", "img3.jpg"]) #analyzing multiple faces same time print(int(obj["age"]), " years old ", obj["dominant_race"], " ", obj["dominant_emotion"], " ", obj["gender"])
def extract_align_face(img): # it return align face result = DeepFace.detectFace(img) # print(result) return result
def verifyWrapper(req, trx_id = 0): resp_obj = jsonify({'success': False}) model_name = "VGG-Face"; distance_metric = "cosine" if "model_name" in list(req.keys()): model_name = req["model_name"] if "distance_metric" in list(req.keys()): distance_metric = req["distance_metric"] #---------------------- instances = [] if "img" in list(req.keys()): raw_content = req["img"] #list for item in raw_content: #item is in type of dict instance = [] img1 = item["img1"]; img2 = item["img2"] validate_img1 = False if len(img1) > 11 and img1[0:11] == "data:image/": validate_img1 = True validate_img2 = False if len(img2) > 11 and img2[0:11] == "data:image/": validate_img2 = True if validate_img1 != True or validate_img2 != True: return jsonify({'success': False, 'error': 'you must pass both img1 and img2 as base64 encoded string'}), 205 instance.append(img1); instance.append(img2) instances.append(instance) #-------------------------- if len(instances) == 0: return jsonify({'success': False, 'error': 'you must pass at least one img object in your request'}), 205 print("Input request of ", trx_id, " has ",len(instances)," pairs to verify") #-------------------------- if model_name == "VGG-Face": resp_obj = DeepFace.verify(instances, model_name = model_name, distance_metric = distance_metric, model = vggface_model) elif model_name == "Facenet": resp_obj = DeepFace.verify(instances, model_name = model_name, distance_metric = distance_metric, model = facenet_model) elif model_name == "OpenFace": resp_obj = DeepFace.verify(instances, model_name = model_name, distance_metric = distance_metric, model = openface_model) elif model_name == "DeepFace": resp_obj = DeepFace.verify(instances, model_name = model_name, distance_metric = distance_metric, model = deepface_model) elif model_name == "x": resp_obj = DeepFace.verify(instances, model_name = modxel_name, distance_metric = distance_metric, model = deepid_model) elif model_name == "ArcFace": resp_obj = DeepFace.verify(instances, model_name = model_name, distance_metric = distance_metric, model = arcface_model) elif model_name == "Ensemble": models = {} models["VGG-Face"] = vggface_model models["Facenet"] = facenet_model models["OpenFace"] = openface_model models["DeepFace"] = deepface_model resp_obj = DeepFace.verify(instances, model_name = model_name, model = models) else: resp_obj = jsonify({'success': False, 'error': 'You must pass a valid model name. You passed %s' % (model_name)}), 205 return resp_obj
def get_face_dict(img_path: str) -> dict: try: return DeepFace.analyze(img_path) except Exception as e: msg = LogTool.pp_exception(e) print(msg)
from deepface import DeepFace demography = DeepFace.analyze("face_images/Gates/1.jpg") print("Age: ", demography["age"]) print("Gender: ", demography["gender"]) print("Emotion: ", demography["dominant_emotion"]) print("Race: ", demography["dominant_race"]) # print(demography)
def detect_deepface_cropped(img, person_boxes, old_ballots, original_boxes): """ takes in a list of person bounding boxes and image crops the image to the bounding boxes and detects from database returns drawn img, person bounding boxes and id-ed name: [(x1, y1), (x2, y2), "ZuoLin"] """ bboxs = [] person_face_detected = [] output_img = img.copy() for i in range(len(person_boxes)): p_bbox = person_boxes[i] o_bbox = original_boxes[i] (xmin, ymin), (xmax, ymax) = p_bbox cropped_img = img[ymin:ymax, xmin:xmax] detections = detect_face2(img=cropped_img, detector_backend=detector_backend, grayscale=grayscale, enforce_detection=enforce_detection) (oxmin, oymin), (oxmax, oymax) = p_bbox o_cropped_img = img[oymin:oymax, oxmin:oxmax] face_detected = None if len(detections) == 1: # Only retain images that has 1 detected face x, y, w, h = detections[0]["box"] y_buffer = int(h * 0.5) x_buffer = int(w * 0.5) detected_face = cropped_img[ max(0, int(y - y_buffer)):min(cropped_img. shape[0], int(y + h + y_buffer)), max(0, int(x - x_buffer)):min(cropped_img. shape[1], int(x + w + x_buffer))] try: ## calls reid_processor to confirm identity # best_body_guess, body_confidence = reid.detect_body_cropped(cropped_img) detected_face = detected_face[:, :, ::-1] new_im = Image.fromarray(detected_face) tmp_image = str(int(time.time())) + ".jpg" new_im.save(tmp_image) df = DeepFace.find(img_path=tmp_image, db_path=db_folder, enforce_detection=False) os.remove(tmp_image) df.sort_values('VGG-Face_cosine', inplace=True, ascending=True) face_detected = re.split(r' |/|\\', df['identity'].iloc[0])[1] dist = float(df['VGG-Face_cosine'].iloc[0]) ## need code when face id is not confident, use reid to confirm/dispute if dist > 0.035: face_detected = None pass else: print('p detected by face:', face_detected) except Exception as err: print("ERROR:", err) if face_detected == None: best_identity, best_confidence = reid.detect_body_cropped( o_cropped_img[:, :, ::-1]) face_detected = best_identity print('p detected by body:', face_detected) bboxs.append( [None, None, None, None, best_confidence, face_detected]) else: bboxs.append([ xmin + x, ymin + y, w, h, detections[0]['confidence'], face_detected ]) person_face_detected.append([(xmin, ymin), (xmax, ymax), face_detected]) old_ballots = assign_new_to_old(person_face_detected, old_ballots, bboxs, original_boxes) for face_detected in old_ballots: print(f"person detected: {face_detected.name}", f"confidence: {face_detected.best_count}") if face_detected.info[0] is not None: output_img = drawBBox(output_img, face_detected.info, col_dict, "yellow") cc = face_detected.o_coords output_img = drawBBox2(output_img, cc[0][0], cc[1][0], cc[0][1], cc[1][1], face_detected.name, col_dict, "yellow") person_detected = [[x.coords[0], x.coords[1], x.name] for x in old_ballots if x.name] return output_img, person_detected, old_ballots
def analysis(db_path, model_name, distance_metric, enable_face_analysis=True, source=0, time_threshold=1, frame_threshold=30): input_shape = (224, 224) input_shape_x = input_shape[0] input_shape_y = input_shape[1] text_color = (255, 255, 255) # employees = [] # #check passed db folder exists # if os.path.isdir(db_path) == True: # for r, d, f in os.walk(db_path): # r=root, d=directories, f = files # for file in f: # if ('.jpg' in file): # #exact_path = os.path.join(r, file) # exact_path = r + "/" + file # #print(exact_path) # employees.append(exact_path) # # if len(employees) == 0: # print("WARNING: There is no image in this path ( ", db_path,") . Face recognition will not be performed.") # # #------------------------ # # if len(employees) > 0: # # model = DeepFace.build_model(model_name) # print(model_name," is built") # # #------------------------ # # input_shape = functions.find_input_shape(model) # input_shape_x = input_shape[0] # input_shape_y = input_shape[1] # # #tuned thresholds for model and metric pair # threshold = dst.findThreshold(model_name, distance_metric) # # #------------------------ # #facial attribute analysis models df8 = pd.DataFrame(columns=['label', 'score']) if enable_face_analysis == True: tic = time.time() emotion_model = DeepFace.build_model('Emotion') print("Emotion model loaded") # age_model = DeepFace.build_model('Age') # print("Age model loaded") # # gender_model = DeepFace.build_model('Gender') # print("Gender model loaded") toc = time.time() print("Facial attibute analysis models loaded in ", toc - tic, " seconds") #------------------------ #find embeddings for employee list #tic = time.time() # pbar = tqdm(range(0, len(employees)), desc='Finding embeddings') embeddings = [] # #for employee in employees: # for index in pbar: # employee = employees[index] # pbar.set_description("Finding embedding for %s" % (employee.split("/")[-1])) # embedding = [] # img = functions.preprocess_face(img = employee, target_size = (input_shape_y, input_shape_x), enforce_detection = False) # img_representation = model.predict(img)[0,:] # # embedding.append(employee) # embedding.append(img_representation) # embeddings.append(embedding) # df = pd.DataFrame(embeddings, columns=['employee', 'embedding']) df['distance_metric'] = distance_metric # # toc = time.time() # # print("Embeddings found for given data set in ", toc-tic," seconds") # # #----------------------- pivot_img_size = 112 #face recognition result image #----------------------- opencv_path = functions.get_opencv_path() face_detector_path = opencv_path + "haarcascade_frontalface_default.xml" face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') #----------------------- freeze = False face_detected = False face_included_frames = 0 #freeze screen if face detected sequantially 5 frames freezed_frame = 0 tic = time.time() cap = cv2.VideoCapture(source) #webcam while (True): ret, img = cap.read() #cv2.namedWindow('img', cv2.WINDOW_FREERATIO) #cv2.setWindowProperty('img', cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN) raw_img = img.copy() resolution = img.shape resolution_x = img.shape[1] resolution_y = img.shape[0] if freeze == False: faces = face_cascade.detectMultiScale(img, 1.3, 5) if len(faces) == 0: face_included_frames = 0 else: faces = [] detected_faces = [] face_index = 0 for (x, y, w, h) in faces: if w > 60: #discard small detected faces face_detected = True if face_index == 0: face_included_frames = face_included_frames + 1 #increase frame for a single face cv2.rectangle(img, (x, y), (x + w, y + h), (67, 67, 67), 1) #draw rectangle to main image #cv2.putText(img, str(frame_threshold - face_included_frames), (int(x+w/4),int(y+h/1.5)), cv2.FONT_HERSHEY_SIMPLEX, 4, (255, 255, 255), 2) detected_face = img[int(y):int(y + h), int(x):int(x + w)] #crop detected face #------------------------------------- detected_faces.append((x, y, w, h)) face_index = face_index + 1 #------------------------------------- if face_detected == True and face_included_frames == frame_threshold and freeze == False: freeze = True #base_img = img.copy() base_img = raw_img.copy() detected_faces_final = detected_faces.copy() tic = time.time() if freeze == True: toc = time.time() if (toc - tic) < time_threshold: if freezed_frame == 0: freeze_img = base_img.copy() #freeze_img = np.zeros(resolution, np.uint8) #here, np.uint8 handles showing white area issue for detected_face in detected_faces_final: x = detected_face[0] y = detected_face[1] w = detected_face[2] h = detected_face[3] cv2.rectangle(freeze_img, (x, y), (x + w, y + h), (67, 67, 67), 1) #draw rectangle to main image #------------------------------- #apply deep learning for custom_face custom_face = base_img[y:y + h, x:x + w] #------------------------------- #facial attribute analysis if enable_face_analysis == True: gray_img = functions.preprocess_face( img=custom_face, target_size=(48, 48), grayscale=True, enforce_detection=False) emotion_labels = [ 'Angry', 'Disgust', 'Fear', 'Happy', 'Sad', 'Surprise', 'Neutral' ] emotion_predictions = emotion_model.predict( gray_img)[0, :] sum_of_predictions = emotion_predictions.sum() mood_items = [] for i in range(0, len(emotion_labels)): mood_item = [] emotion_label = emotion_labels[i] emotion_prediction = 100 * emotion_predictions[ i] / sum_of_predictions mood_item.append(emotion_label) mood_item.append(emotion_prediction) mood_items.append(mood_item) emotion_df = pd.DataFrame( mood_items, columns=["emotion", "score"]) emotion_df = emotion_df.sort_values( by=["score"], ascending=False).reset_index(drop=True) #background of mood box #transparency overlay = freeze_img.copy() opacity = 0.4 if x + w + pivot_img_size < resolution_x: #right cv2.rectangle( freeze_img #, (x+w,y+20) , (x + w, y), (x + w + pivot_img_size, y + h), (64, 64, 64), cv2.FILLED) cv2.addWeighted(overlay, opacity, freeze_img, 1 - opacity, 0, freeze_img) elif x - pivot_img_size > 0: #left cv2.rectangle( freeze_img #, (x-pivot_img_size,y+20) , (x - pivot_img_size, y), (x, y + h), (64, 64, 64), cv2.FILLED) cv2.addWeighted(overlay, opacity, freeze_img, 1 - opacity, 0, freeze_img) for index, instance in emotion_df.iterrows(): emotion_label = "%s " % (instance['emotion']) emotion_score = instance['score'] / 100 bar_x = 35 #this is the size if an emotion is 100% bar_x = int(bar_x * emotion_score) labelx = { 'label': emotion_label, 'score': emotion_score } df8 = df8.append(labelx, ignore_index=True) ser = pd.Series(data=labelx, index=['label', 'score']) if x + w + pivot_img_size < resolution_x: text_location_y = y + 20 + (index + 1) * 20 text_location_x = x + w if text_location_y < y + h: cv2.putText( freeze_img, emotion_label, (text_location_x, text_location_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) cv2.rectangle( freeze_img, (x + w + 70, y + 13 + (index + 1) * 20), (x + w + 70 + bar_x, y + 13 + (index + 1) * 20 + 5), (255, 255, 255), cv2.FILLED) elif x - pivot_img_size > 0: text_location_y = y + 20 + (index + 1) * 20 text_location_x = x - pivot_img_size if text_location_y <= y + h: cv2.putText( freeze_img, emotion_label, (text_location_x, text_location_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) cv2.rectangle( freeze_img, (x - pivot_img_size + 70, y + 13 + (index + 1) * 20), (x - pivot_img_size + 70 + bar_x, y + 13 + (index + 1) * 20 + 5), (255, 255, 255), cv2.FILLED) if emotion_label != 'Happy': cv2.cv2.putText( freeze_img, "Smile", (40, 70), cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 255, 255), 1) #------------------------------- # face_224 = functions.preprocess_face(img = custom_face, target_size = (224, 224), grayscale = False, enforce_detection = False) # # age_predictions = awebcamge_model.predict(face_224)[0,:] # apparent_age = Age.findApparentAge(age_predictions) #------------------------------- # gender_prediction = gender_model.predict(face_224)[0,:] # # if np.argmax(gender_prediction) == 0: # gender = "W" # elif np.argmax(gender_prediction) == 1: # gender = "M" # # #print(str(int(apparent_age))," years old ", dominant_emotion, " ", gender) # # analysis_report = str(int(apparent_age))+" "+gender #------------------------------- info_box_color = (46, 200, 255) #top # if y - pivot_img_size + int(pivot_img_size/5) > 0: # # triangle_coordinates = np.array( [ # (x+int(w/2), y) # , (x+int(w/2)-int(w/10), y-int(pivot_img_size/3)) # , (x+int(w/2)+int(w/10), y-int(pivot_img_size/3)) # ] ) # # cv2.drawContours(freeze_img, [triangle_coordinates], 0, info_box_color, -1) # # cv2.rectangle(freeze_img, (x+int(w/5), y-pivot_img_size+int(pivot_img_size/5)), (x+w-int(w/5), y-int(pivot_img_size/3)), info_box_color, cv2.FILLED) # # cv2.putText(freeze_img, analysis_report, (x+int(w/3.5), y - int(pivot_img_size/2.1)), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 111, 255), 2) #bottom # elif y + h + pivot_img_size - int(pivot_img_size/5) < resolution_y: # # triangle_coordinates = np.array( [ # (x+int(w/2), y+h) # , (x+int(w/2)-int(w/10), y+h+int(pivot_img_size/3)) # , (x+int(w/2)+int(w/10), y+h+int(pivot_img_size/3)) # ] ) # # cv2.drawContours(freeze_img, [triangle_coordinates], 0, info_box_color, -1) # # cv2.rectangle(freeze_img, (x+int(w/5), y + h + int(pivot_img_size/3)), (x+w-int(w/5), y+h+pivot_img_size-int(pivot_img_size/5)), info_box_color, cv2.FILLED) # # cv2.putText(freeze_img, analysis_report, (x+int(w/3.5), y + h + int(pivot_img_size/1.5)), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 111, 255), 2) #------------------------------- #face recognition custom_face = functions.preprocess_face( img=custom_face, target_size=(input_shape_y, input_shape_x), enforce_detection=False) #check preprocess_face function handled if custom_face.shape[1:3] == input_shape: if df.shape[ 0] > 0: #if there are images to verify, apply face recognition img1_representation = model.predict( custom_face)[0, :] #print(freezed_frame," - ",img1_representation[0:5]) def findDistance(row): distance_metric = row['distance_metric'] img2_representation = row['embedding'] distance = 1000 #initialize very large value if distance_metric == 'cosine': distance = dst.findCosineDistance( img1_representation, img2_representation) elif distance_metric == 'euclidean': distance = dst.findEuclideanDistance( img1_representation, img2_representation) elif distance_metric == 'euclidean_l2': distance = dst.findEuclideanDistance( dst.l2_normalize( img1_representation), dst.l2_normalize( img2_representation)) return distance df['distance'] = df.apply(findDistance, axis=1) df = df.sort_values(by=["distance"]) candidate = df.iloc[0] employee_name = candidate['employee'] best_distance = candidate['distance'] #print(candidate[['employee', 'distance']].values) #if True: if best_distance <= threshold: #print(employee_name) display_img = cv2.imread(employee_name) display_img = cv2.resize( display_img, (pivot_img_size, pivot_img_size)) label = employee_name.split( "/")[-1].replace(".jpg", "") label = re.sub('[0-9]', '', label) try: if y - pivot_img_size > 0 and x + w + pivot_img_size < resolution_x: #top right freeze_img[ y - pivot_img_size:y, x + w:x + w + pivot_img_size] = display_img overlay = freeze_img.copy() opacity = 0.4 cv2.rectangle( freeze_img, (x + w, y), (x + w + pivot_img_size, y + 20), (46, 200, 255), cv2.FILLED) cv2.addWeighted( overlay, opacity, freeze_img, 1 - opacity, 0, freeze_img) cv2.putText( freeze_img, label, (x + w, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, text_color, 1) #connect face and text cv2.line(freeze_img, (x + int(w / 2), y), (x + 3 * int(w / 4), y - int(pivot_img_size / 2)), (67, 67, 67), 1) cv2.line(freeze_img, (x + 3 * int(w / 4), y - int(pivot_img_size / 2)), (x + w, y - int(pivot_img_size / 2)), (67, 67, 67), 1) elif y + h + pivot_img_size < resolution_y and x - pivot_img_size > 0: #bottom left freeze_img[ y + h:y + h + pivot_img_size, x - pivot_img_size:x] = display_img overlay = freeze_img.copy() opacity = 0.4 cv2.rectangle( freeze_img, (x - pivot_img_size, y + h - 20), (x, y + h), (46, 200, 255), cv2.FILLED) cv2.addWeighted( overlay, opacity, freeze_img, 1 - opacity, 0, freeze_img) cv2.putText( freeze_img, label, (x - pivot_img_size, y + h - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, text_color, 1) #connect face and text cv2.line(freeze_img, (x + int(w / 2), y + h), (x + int(w / 2) - int(w / 4), y + h + int(pivot_img_size / 2)), (67, 67, 67), 1) cv2.line(freeze_img, (x + int(w / 2) - int(w / 4), y + h + int(pivot_img_size / 2)), (x, y + h + int(pivot_img_size / 2)), (67, 67, 67), 1) elif y - pivot_img_size > 0 and x - pivot_img_size > 0: #top left freeze_img[ y - pivot_img_size:y, x - pivot_img_size:x] = display_img overlay = freeze_img.copy() opacity = 0.4 cv2.rectangle( freeze_img, (x - pivot_img_size, y), (x, y + 20), (46, 200, 255), cv2.FILLED) cv2.addWeighted( overlay, opacity, freeze_img, 1 - opacity, 0, freeze_img) cv2.putText( freeze_img, label, (x - pivot_img_size, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, text_color, 1) #connect face and text cv2.line( freeze_img, (x + int(w / 2), y), (x + int(w / 2) - int(w / 4), y - int(pivot_img_size / 2)), (67, 67, 67), 1) cv2.line( freeze_img, (x + int(w / 2) - int(w / 4), y - int(pivot_img_size / 2)), (x, y - int(pivot_img_size / 2)), (67, 67, 67), 1) elif x + w + pivot_img_size < resolution_x and y + h + pivot_img_size < resolution_y: #bottom righ freeze_img[ y + h:y + h + pivot_img_size, x + w:x + w + pivot_img_size] = display_img overlay = freeze_img.copy() opacity = 0.4 cv2.rectangle( freeze_img, (x + w, y + h - 20), (x + w + pivot_img_size, y + h), (46, 200, 255), cv2.FILLED) cv2.addWeighted( overlay, opacity, freeze_img, 1 - opacity, 0, freeze_img) cv2.putText( freeze_img, label, (x + w, y + h - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, text_color, 1) #connect face and text cv2.line(freeze_img, (x + int(w / 2), y + h), (x + int(w / 2) + int(w / 4), y + h + int(pivot_img_size / 2)), (67, 67, 67), 1) cv2.line(freeze_img, (x + int(w / 2) + int(w / 4), y + h + int(pivot_img_size / 2)), (x + w, y + h + int(pivot_img_size / 2)), (67, 67, 67), 1) except Exception as err: print(str(err)) tic = time.time( ) #in this way, freezed image can show 5 seconds #------------------------------- time_left = int(time_threshold - (toc - tic) + 1) cv2.rectangle(freeze_img, (10, 10), (90, 50), (67, 67, 67), -10) cv2.putText(freeze_img, str(time_left), (40, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 1) df9 = df8.tail(7) cv2.imshow('Title Of Th Project', freeze_img) df9.to_csv('out.csv') df8.to_csv('history.csv') df_final = pd.read_csv('out.csv') freezed_frame = freezed_frame + 1 else: face_detected = False face_included_frames = 0 freeze = False freezed_frame = 0 else: cv2.imshow('Title Of Th Project', img) if cv2.waitKey(1) & 0xFF == ord('q'): #press q to quit break #kill open cv things cap.release() cv2.destroyAllWindows()
def verify(): global graph tic = time.time() req = request.get_json() trx_id = uuid.uuid4() resp_obj = jsonify({'success': False}) with graph.as_default(): model_name = "VGG-Face" distance_metric = "cosine" if "model_name" in list(req.keys()): model_name = req["model_name"] if "distance_metric" in list(req.keys()): distance_metric = req["distance_metric"] #---------------------- instances = [] if "img" in list(req.keys()): raw_content = req["img"] #list for item in raw_content: #item is in type of dict instance = [] img1 = item["img1"] img2 = item["img2"] validate_img1 = False if len(img1) > 11 and img1[0:11] == "data:image/": validate_img1 = True validate_img2 = False if len(img2) > 11 and img2[0:11] == "data:image/": validate_img2 = True if validate_img1 != True or validate_img2 != True: return jsonify({ 'success': False, 'error': 'you must pass both img1 and img2 as base64 encoded string' }), 205 instance.append(img1) instance.append(img2) instances.append(instance) #-------------------------- if len(instances) == 0: return jsonify({ 'success': False, 'error': 'you must pass at least one img object in your request' }), 205 print("Input request of ", trx_id, " has ", len(instances), " pairs to verify") #-------------------------- if model_name == "VGG-Face": resp_obj = DeepFace.verify(instances, model_name=model_name, distance_metric=distance_metric, model=vggface_model) elif model_name == "Facenet": resp_obj = DeepFace.verify(instances, model_name=model_name, distance_metric=distance_metric, model=facenet_model) elif model_name == "OpenFace": resp_obj = DeepFace.verify(instances, model_name=model_name, distance_metric=distance_metric, model=openface_model) elif model_name == "DeepFace": resp_obj = DeepFace.verify(instances, model_name=model_name, distance_metric=distance_metric, model=deepface_model) elif model_name == "Ensemble": models = {} models["VGG-Face"] = vggface_model models["Facenet"] = facenet_model models["OpenFace"] = openface_model models["DeepFace"] = deepface_model resp_obj = DeepFace.verify(instances, model_name=model_name, model=models) else: return jsonify({ 'success': False, 'error': 'You must pass a valid model name. Available models are VGG-Face, Facenet, OpenFace, DeepFace but you passed %s' % (model_name) }), 205 #-------------------------- toc = time.time() resp_obj["trx_id"] = trx_id resp_obj["seconds"] = toc - tic return resp_obj, 200
if __name__ == "__main__": dspth = 'res/test-img/FinalData' pre_models = {} pre_models['emotion'] = loadModel_emotion() pre_models['age'] = loadModel_age() pre_models['gender'] = loadModel_gender() pre_models['race'] = loadModel_race() if not writeFile: image_name = '101.jpeg' src = cv2.imread(osp.join(dspth, image_name)) all_contour(src) demography = DeepFace.analyze( osp.join(dspth, image_name), actions=['age', 'gender', 'race', 'emotion'], models=pre_models) race_judge = 'asian' for key, value in demography['race'].items(): if value == max(demography['race'].values()): race_judge = key if race_judge == 'asian': feature['race'] = 1 elif race_judge == 'black': feature['race'] = 0 elif race_judge == 'white': feature['race'] = 2 else: feature['race'] = 1 feature['eye'] = 1 if description['glasses'] == 1 else 0
#pip install deepface from deepface import DeepFace DeepFace.stream('dataset')
# pred = [] # pair = all_pairs[i] # print(len(pair)) # """result = DeepFace.verify([pair], enforce_detection = False) # pred.append(result["pair_1"]["verified"])""" # try: # result = DeepFace.verify([pair]) # pred.append(result["pair_1"]["verified"]) # except ValueError: # pred.append(2) ### first line runs deepface with default vgg model and second line runs it with Facenet model models will be automaticly downloaded # result = DeepFace.verify(all_pairs, enforce_detection= False) result = DeepFace.verify(all_pairs, enforce_detection=False, model_name="Facenet") #print(result) ### write results to txt file with open("facenet_model_output.txt", "w") as file: for i in range(0, 4000): # for i in range(0,len(all_pairs[0:10])): file.write(str(result["pair_" + str(i + 1)]["verified"]) + "\n") # i = 1 # for res in result: # print(res) # file.write(str(res["pair_" + str(i)]["verified"]) + "\n") # i += 1 """"try:
def get_emotion(): DATAFRAMESOUT = os.getenv("DATA_FRAMES_OUT") PATHIN = os.getenv("PATH_IN") PATHOUT = os.getenv("PATH_OUT") img_array = [] dfs = [] video_paths = [] video_names = [] person_folder_names = [] # added the video counter here so it does not depend on the previous function video_counter = 0 # how many videos there are for i in os.listdir(PATHIN): person_folder = PATHIN + i for vid_folder in os.listdir(person_folder): vid_folder = person_folder + "/" + vid_folder for video in os.listdir(vid_folder): video_names.append( video) # saving just the name of the video into an array video = vid_folder + "/" + video video_paths.append( video ) # saving the whole path of the video into another array person_folder_names.append( i) # add an instance of 'folder name' for each video video_counter += 1 for i in range(0, video_counter, 1): for filename in glob.glob(PATHOUT + 'video%d' % i + 'frame*.jpg'): # Read in the relevant images img = cv2.imread(filename) height, width, layers = img.shape size = (width, height) img_array.append(img) # Pass them through deepface face_FER = DeepFace.analyze(img_path=img_array, actions=['emotion'], enforce_detection=False) img_array = [] # reset image array to be blank data = face_FER # Turning arrays into pandas dataframes and labelling emotions emotions = set() # First we need to find out all unique emotions for key, value in data.items(): for emotion in value['emotion'].keys(): emotions.add(emotion) rows = [] columns = ['instance'] + list(emotions) for key, value in data.items(): rows.append([0] * len(columns)) # Start creating a new row with zeros key = key.split('_')[1] # Get the 1,2,3 out of the instance rows[-1][0] = key for emotion, emotion_value in value['emotion'].items(): rows[-1][columns.index( emotion )] = emotion_value # place the emotion in the correct index df = pd.DataFrame(rows, columns=columns) df.set_index('instance', inplace=True) dfs.append(df) # TODO: need to index this with 'video names' # index_arrays = (person_folder_names, video_names) dfs_index = pd.MultiIndex.from_arrays(index_arrays, names=["person", "video"]) dfs_frame = pd.DataFrame(dfs, index=dfs_index, columns=[ 'video_emotion' ]) #dataframe indexed by folder name and video name (two levels) dfs_frame.to_pickle(DATAFRAMESOUT + 'dfs_frame.pkl')