def ff(img): """ :param img: :return: faceAligned[0] the aligned face version of the original input image """ # initialize dlib's face detector (HOG-based) and then create # the facial landmark predictor and the face aligner detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(str(_path) + "/shape_predictor_68_face_landmarks.dat") ######################## fa = FaceAligner(predictor, desiredFaceWidth=256) # load the input image, resize it, and convert it to grayscale image = img ########################################################## image = imutils.resize(image, width=800) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # show the original input image and detect faces in the grayscale # image #cv2.imshow("Input", image) rects = detector(gray, 2) lst = [] # loop over the face detections for rect in rects: # extract the ROI of the *original* face, then align the face # using facial landmarks (x, y, w, h) = rect_to_bb(rect) faceOrig = imutils.resize(image[y:y + h, x:x + w], width=256) faceAligned = fa.align(image, gray, rect) import uuid f = str(uuid.uuid4()) cv2.imwrite("foo/" + f + ".png", faceAligned) # display the output images #cv2.imshow("Original", faceOrig) #cv2.imshow("Aligned", faceAligned) #cv2.waitKey(0) lst.append(faceAligned) return lst[0]
os.chdir('..') for n in range(len(time_array)): # frame = cv2.imread('info/' + str(time_array[n]) + '.jpg') frame = imutils.resize(frame, width=600) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) height, width = frame.shape[:2] rects = detector(gray, 0) i = 0 if (len(rects) > 0): array_data_not_col = [] for rect in rects: (x, y, w, h) = face_utils.rect_to_bb(rect) if (x > 0 and y > 0 and x + w < width and y + h < height): i += 1 start = time_array[n] shape_cam = predictor(gray, rect) shape = face_utils.shape_to_np(shape_cam) gor = np.sqrt((shape[0][0] - shape[16][0])**2 + (shape[0][1] - shape[16][1])**2) vert = np.sqrt((shape[8][0] - shape[27][0])**2 + (shape[8][1] - shape[27][1])**2) otn = gor / vert face_descriptor = facerec.compute_face_descriptor(
# initialize dlib's face detector (HOG-based) and then create # the facial landmark predictor and the face aligner # detector = dlib.cnn_face_detection_model_v1(args["weights"]) detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(args["shape_predictor"]) fa = FaceAligner(predictor, desiredFaceWidth=256) # load the input image, resize it, and convert it to grayscale image = cv2.imread(args["image"]) image = imutils.resize(image, width=800) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # show the original input image and detect faces in the grayscale # image cv2.imshow("Input", image) rects = detector(gray, 2) # loop over the face detections for rect in rects: # extract the ROI of the *original* face, then align the face # using facial landmarks (x, y, w, h) = rect_to_bb(rect) faceOrig = imutils.resize(image[y:y + h, x:x + w], width=256) faceAligned = fa.align(image, gray, rect) # display the output images cv2.imshow("Original", faceOrig) cv2.imshow("Aligned", faceAligned) cv2.waitKey(0)
#ap.add_argument("-i", "--image", required=True, help="path to input image") #ap.add_argument('--draw', nargs='?', const=True, type=bool, default=False, help="Fill landmarks") #args = vars(ap.parse_args()) detector = dlib.get_frontal_face_detector() #standard Histogram of Oriented Gradients + Linear SVM method for object detection. predictor = dlib.shape_predictor("./shape_predictor_68_face_landmarks.dat") image = cv2.imread("bts.jpg") image = imutils.resize(image, width=500) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) rect = detector(gray, 1) for (i, rect) in enumerate(rect): shape = predictor(gray, rect) shape = face_utils.shape_to_np( shape) # coverts object to Numpy array with(68,2) (x, y, w, h) = face_utils.rect_to_bb( rect) #draw bounding box surrounding the detected face cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2) #show the face number cv2.putText(image, "Face #{}".format(i + 1), (x - 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) #draw facial landmarks one image for (x, y) in shape: cv2.circle(image, (x, y), 1, (0, 0, 255), -1) cv2.imshow("Output", image) cv2.waitKey(0)
def main(): width = 800 height = 600 # construct the argument parser and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-p", "--shape-predictor", required=True, help="path to facial landmark predictor") ap.add_argument("-v", "--video", required=True, help="path to input video") #ap.add_argument("-n", "--num-frames", type=int, default=2000, # help="# of frames to loop over for FPS test") args = vars(ap.parse_args()) #initialize dlib's face detector (HOG-based) and then create # the facial landmark predictor detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(args["shape_predictor"]) clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) # load the input image, resize it, and convert it to grayscale #cap = cv2.VideoCapture(args["video"]) print("[INFO] starting video file thread...") cap = cv2.VideoCapture(args["video"]) #time.sleep(1) # start the FPS timer fps = FPS().start() window_name = "cctv" cv2.namedWindow(window_name, WINDOW_NORMAL) cv2.resizeWindow(window_name, width, height) if cap.isOpened(): ret, image = cap.read() gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Assign new height and width for ROI (xr, yr, wr, hr) = cv2.boundingRect(gray) startYROI = 3 * hr / 5 endYROI = hr - 1 * hr / 20 else: print "Camera is not open" while ret: cv2.rectangle(image, (0, startYROI), (wr, endYROI), (0, 255, 0), 2) roi_image = image[startYROI:endYROI, 0:wr] #image = cv2.imread(args["image"]) #image = cv2.resize(image, (width, height), interpolation = cv2.INTER_CUBIC) #image_scaled = cv2.resize(image, (600, 500), interpolation=cv2.INTER_AREA) gray = cv2.cvtColor(roi_image, cv2.COLOR_BGR2GRAY) #pil_gray = Image.fromarray(gray) #pil_gray = pil_gray.resize((width, height), Image.BICUBIC) #cv_gray = np.array(pil_gray) #roi = image[] # detect faces in the grayscale image rects = detector(gray, 0) # loop over the face detections for (i, rect) in enumerate(rects): # determine the facial landmarks for the face region, then # convert the facial landmark (x, y)-coordinates to a NumPy array shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) # convert dlib's rectangle to a OpenCV-style bounding box # [i.e., (x, y, w, h)], then draw the face bounding box (x, y, w, h) = face_utils.rect_to_bb(rect) cv2.rectangle(image, (x, (y + startYROI)), (x + w, (y + startYROI) + h), (0, 255, 0), 2) # show the face number cv2.putText(image, "Face #{}".format(i + 1), (x - 10, y + startYROI - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) # loop over the (x, y)-coordinates for the facial landmarks # and draw them on the image for (x, y) in shape: cv2.circle(image, (x, (y + startYROI)), 1, (0, 0, 255), -1) # show the output image with the face detections + facial landmarks cv2.imshow(window_name, image) ret, image = cap.read() if cv2.waitKey(1) & 0xff == ord('q'): break fps.update() fps.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) # do a bit of cleanup cap.release() cv2.destroyAllWindows()
def begin_classifier(): fourcc = cv2.VideoWriter_fourcc(*'MJPG') out = cv2.VideoWriter('DT.avi', fourcc, 4.0, (200, 112)) option = input("Use pre-trained model(1) or train again(2) ? ") if option == 1: # Loading the saved decision tree model pickle decision_tree_pkl = 'resources/decision_tree_classifier.pkl' decision_tree_model_pkl = open(decision_tree_pkl_filename, 'rb') clf = pickle.load(decision_tree_model_pkl) else: clf = prepare_dataset() # Decision tree model # initialize dlib's face detector (HOG-based) and then create # the facial landmark predictor print("[INFO] loading facial landmark predictor...") detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor( "resources/shape_predictor_68_face_landmarks.dat") headCascade = cv2.CascadeClassifier("resources/haarcascade_head.xml") faceCascade = cv2.CascadeClassifier( "resources/haarcascade_frontalface_alt.xml") # initialize the video stream and allow the camera sensor to warmup print("[INFO] camera sensor warming up...") vs = cv2.VideoCapture(0) vs.set(cv2.CAP_PROP_FPS, 8.0) time.sleep(2.0) inAttention = False lastAttentionFrame = 0 lastAttentionFrameThresh = 48 frameNumber = 0 (lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"] (rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"] xlast = 0 ylast = 0 hlast = 0 wlast = 0 # loop over the frames from the video stream while True: # grab the frame from the threaded video stream, resize it to # have a maximum width of 400 pixels, and convert it to # grayscale ret, frame = vs.read() #framecrop = frame frame = imutils.resize(frame, width=200) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) frameNumber = frameNumber + 1 # detect faces in the grayscale frame # rects = detector(gray, 0) faces = faceCascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(50, 50), maxSize=(200, 200), flags=cv2.CASCADE_SCALE_IMAGE) if (len(faces) > 0): for (x, y, w, h) in faces: xlast = x ylast = y hlast = h wlast = w rect = dlib.rectangle(int(x), int(y), int(x + w), int(y + h)) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) ns = [] for (xs, ys) in shape: # cv2.circle(frame, (xs, ys), 1, (0, 255, 0), -1) ns.append(xs - x) ns.append(ys - y) leftEye = shape[lStart:lEnd] rightEye = shape[rStart:rEnd] leftEAR = eye_aspect_ratio(leftEye) rightEAR = eye_aspect_ratio(rightEye) ns.append(leftEAR) ns.append(rightEAR) ns = np.asarray(ns) ys = clf.predict([ns]) if (leftEAR + rightEAR < 0.5): cv2.putText(frame, "EAR EYES CLOSED", (200, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("EAR EYES CLOSED") if (ys == 1.0): cv2.putText(frame, "NORMAL MODE", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) elif (ys == 2.0): cv2.putText(frame, "Looking DOWN", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("LOOKING DOWN") elif (ys == 3.0): cv2.putText(frame, "Looking LEFT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("LOOKING LEFT") elif (ys == 4.0): cv2.putText(frame, "Looking RIGHT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("LOOKING RIGHT") elif (ys == 5.0): cv2.putText(frame, "Looking UP", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("LOOKING UP") elif (ys == 6.0): cv2.putText(frame, "DT EYES CLOSED", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("DT EYES CLOSED") elif (ys == 7.0): cv2.putText(frame, "YAWNING", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("YAWNING") else: graycrop = gray[ylast - int(0.5 * hlast):ylast + int(1.5 * hlast), xlast - int(0.5 * wlast):xlast + int(1.5 * wlast)].copy() framecrop = frame[ylast - int(0.5 * hlast):ylast + int(1.5 * hlast), xlast - int(0.5 * wlast):int(xlast + 1.5 * wlast)].copy() rects = detector(graycrop, 0) if (len(rects) > 0): for rect in rects: (x, y, w, h) = face_utils.rect_to_bb(rect) cv2.rectangle(framecrop, (x, y), (x + w, y + h), (0, 0, 255), 2) shape = predictor(graycrop, rect) shape = face_utils.shape_to_np(shape) ns = [] for (xs, ys) in shape: # cv2.circle(framecrop, (xs, ys), 1, (0, 0, 255), -1) ns.append(xs - x) ns.append(ys - y) leftEye = shape[lStart:lEnd] rightEye = shape[rStart:rEnd] leftEAR = eye_aspect_ratio(leftEye) rightEAR = eye_aspect_ratio(rightEye) ns.append(leftEAR) ns.append(rightEAR) ns = np.asarray(ns) ys = clf.predict([ns]) if (leftEAR + rightEAR < 0.5): cv2.putText(frame, "EYES CLOSED using EAR", (200, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("EYES CLOSED USING EAR") if (ys == 1.0): cv2.putText(frame, "NORMAL MODE", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("NORMAL MODE") elif (ys == 2.0): cv2.putText(frame, "Looking DOWN", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking DOWN") elif (ys == 3.0): cv2.putText(frame, "Looking LEFT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking LEFT") elif (ys == 4.0): cv2.putText(frame, "Looking RIGHT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking RIGHT") elif (ys == 5.0): cv2.putText(frame, "Looking UP", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking UP") elif (ys == 6.0): cv2.putText(frame, "EYES CLOSED using DT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("EYES CLOSED using DT") elif (ys == 7.0): cv2.putText(frame, "YAWNING", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("YAWNING") else: profile = cv2.CascadeClassifier(config.casc3).detectMultiScale( gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30), maxSize=(120, 120), flags=cv2.CASCADE_SCALE_IMAGE) if len(profile) > 0: # I detected a right profile for (x, y, w, h) in profile: xlast = x ylast = y hlast = h wlast = w rect = dlib.rectangle(int(x), int(y), int(x + w), int(y + h)) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) ns = [] for (xs, ys) in shape: # cv2.circle(frame, (xs, ys), 1, (0, 255, 0), -1) ns.append(xs - x) ns.append(ys - y) leftEye = shape[lStart:lEnd] rightEye = shape[rStart:rEnd] leftEAR = eye_aspect_ratio(leftEye) rightEAR = eye_aspect_ratio(rightEye) ns.append(leftEAR) ns.append(rightEAR) ns = np.asarray(ns) ys = clf.predict([ns]) if (leftEAR + rightEAR < 0.5): cv2.putText(frame, "EYES CLOSED using EAR", (200, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("EYES CLOSED USING EAR") if (ys == 1.0): cv2.putText(frame, "NORMAL MODE", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("NORMAL MODE") elif (ys == 2.0): cv2.putText(frame, "Looking DOWN", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking DOWN") elif (ys == 3.0): cv2.putText(frame, "Looking LEFT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking LEFT") elif (ys == 4.0): cv2.putText(frame, "Looking RIGHT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking RIGHT") elif (ys == 5.0): cv2.putText(frame, "Looking UP", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking UP") elif (ys == 6.0): cv2.putText(frame, "EYES CLOSED using DT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("EYES CLOSED using DT") elif (ys == 7.0): cv2.putText(frame, "YAWNING", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("YAWNING") else: # Flip frame, check for left profile flippedFrame = cv2.flip(gray, 1) # horizontal flip profile = cv2.CascadeClassifier( config.casc3).detectMultiScale( flippedFrame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30), maxSize=(120, 120), flags=cv2.CASCADE_SCALE_IMAGE) if len(profile): # I detected a left profile for (x, y, w, h) in profile: xlast = x ylast = y hlast = h wlast = w rect = dlib.rectangle(int(x), int(y), int(x + w), int(y + h)) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) ns = [] for (xs, ys) in shape: # cv2.circle(frame, (xs, ys), 1, (0, 255, 0), -1) ns.append(xs - x) ns.append(ys - y) leftEye = shape[lStart:lEnd] rightEye = shape[rStart:rEnd] leftEAR = eye_aspect_ratio(leftEye) rightEAR = eye_aspect_ratio(rightEye) ns.append(leftEAR) ns.append(rightEAR) ns = np.asarray(ns) ys = clf.predict([ns]) if (leftEAR + rightEAR < 0.5): cv2.putText(frame, "EYES CLOSED using EAR", (200, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("EYES CLOSED USING EAR") if (ys == 1.0): cv2.putText(frame, "NORMAL MODE", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("NORMAL MODE") elif (ys == 2.0): cv2.putText(frame, "Looking DOWN", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking DOWN") elif (ys == 3.0): cv2.putText(frame, "Looking LEFT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking LEFT") elif (ys == 4.0): cv2.putText(frame, "Looking RIGHT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking RIGHT") elif (ys == 5.0): cv2.putText(frame, "Looking UP", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("Looking UP") elif (ys == 6.0): cv2.putText(frame, "EYES CLOSED using DT", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("EYES CLOSED using DT") elif (ys == 7.0): cv2.putText(frame, "YAWNING", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2) print("YAWNING") # show the frame cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF # Saving image for testing # timestamp = getTime() # myPath = testPath + timestamp + ".jpg" # cv2.imwrite(myPath, frame) out.write(frame) # if the `q` key was pressed, break from the loop if key == ord("q"): break # do a bit of cleanup cv2.destroyAllWindows() vs.stop()
def eye_blink_video(self, frame, detector, predictor, COUNTER, TOTAL, ear_top): eyes_detect = '' rects = detector(frame, 1) (left_s, left_e) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"] (right_s, right_e) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"] # andiamo a rilevare il rettangolo del volto e croppiamo l'immagine con 200x200 # un crop più piccolo rispetto a quello di webcam (200x200) perché l'analisi tramite webcam era abbastanza veloce # (molti fps), mentre l'analisi dei video è molto lenta e (200x200) è sufficiente per un buon eyeblink detection. for rect in rects: (x, y, w, h) = face_utils.rect_to_bb(rect) crop = frame[y:y + h, x:x + w] try: crop = cv2.resize(crop, (DIMENSION, DIMENSION)) except Exception as e: print(str(e)) break rects1 = detector(crop, 1) for rect in rects1: shape = predictor(crop, rect) shape = face_utils.shape_to_np(shape) # rilevamento degli occhi e calcolo dell'EAR di entrambe gli occhi leftEye = shape[left_s:left_e] rightEye = shape[right_s:right_e] left_eye_EAR = self.eye_aspect_ratio(leftEye) right_eye_EAR = self.eye_aspect_ratio(rightEye) ear = (left_eye_EAR + right_eye_EAR) / 2.0 leftEyeHull = cv2.convexHull(leftEye) rightEyeHull = cv2.convexHull(rightEye) cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1) cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1) # se ear_top è già stato assegnato allora viene calcolato il threshold if ear_top != 0: ear_threshold = (ear_top * 2) / 3 print("Ear_th", ear_threshold) print("EAR TOP", ear_top) # se ear < del suo threshold if ear < ear_threshold: # abbiamo lo stato di occhi chiusi e incrementiamo il contatore dei frame eyes_detect = '1' COUNTER += 1 else: # quando l'occhio è aperto o di nuovo aperto andiamo a confrontare il contatore # se ha raggiunto i minimi frame consecutivi e se lo è abbiamo avuto un eyeblink # e aumentiamo total (indica il numero di eyeblink) di conseguenza il contatore viene azzerato. eyes_detect = '0' if COUNTER >= CONSEC_FRAMES_NUMBER: TOTAL += 1 COUNTER = 0 cv2.putText(frame, "Blinks: {}".format(TOTAL), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) cv2.putText(frame, "EAR: {:.2f}".format(ear), (200, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) # ear è maggiore di ear_top lo sostituisce, ricordo che ear_top ad inizio video è a 0 e serve # per calcolare il threshold if ear > ear_top: ear_top = ear cv2.imshow('Frame', frame) cv2.waitKey(1) return eyes_detect, COUNTER, TOTAL, ear_top
def hog(self, image): gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) for face in self.faceDetect(gray, 1): (x, y, w, h) = face_utils.rect_to_bb(face) self.faces.append([x, y, x + w, y + h])
def gen_emp_face(emp_name): vs = cv2.VideoCapture(0) time.sleep(3.0) face_found = False cropped_face = None correct_image = None time_prev = time.time() count = 0 if os.path.exists(FACES_PARENT + emp_name): shutil.rmtree(FACES_PARENT + emp_name) os.mkdir(FACES_PARENT + emp_name) while True: __, frame = vs.read() frame = imutils.resize(frame, width=400) frame = cv2.flip(frame, 1) frame_orig = frame.copy() draw_map(frame, count) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) rects = detector(gray, 0) if len(rects) == 0: text = "No face found" cv2.putText(frame, text, (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) elif len(rects) > 1: text = "{} face(s) found. Please be single in the frame.".format( len(rects)) cv2.putText(frame, text, (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) elif len(rects) == 1: text = "Face detected" cv2.putText(frame, text, (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) rect = rects[0] (bx, by, bw, bh) = face_utils.rect_to_bb(rect) cv2.rectangle(frame, (bx, by), (bx + bw, by + bh), (0, 255, 0), 1) shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) face_points = [] inside = True for (i, (x, y)) in enumerate(shape): cv2.circle(frame, (x, y), 1, (0, 0, 255), -1) face_points.append((x, y)) if x > 270 or x < 110 or y < 30 or y > 135 and i != 4: inside = False eye1_cen = ((face_points[0][0] + face_points[1][0]) // 2, (face_points[0][1] + face_points[1][1]) // 2) eye2_cen = ((face_points[2][0] + face_points[3][0]) // 2, (face_points[2][1] + face_points[3][1]) // 2) angle = slope(eye1_cen, eye2_cen) cv2.putText(frame, str(angle), (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) # print(time_prev-time.time()) if time.time() - time_prev > 1 and count <= 25 and inside: time_capture = time.time() time_prev = time_capture adjusted = correct_orientation(frame_orig, rect) cv2.imwrite( FACES_PARENT + emp_name + "/" + str(count) + ".jpg", adjusted) count += 1 elif not inside: cv2.putText(frame, "Be inside the grid", (150, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2) if count > 25: cv2.putText(frame, "Done, Press q", (200, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2) cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF if key == ord("q"): break if count < 25: return False vs.release() cv2.destroyAllWindows() return True
def face_full_process(self, frame, type, face_detect_on, age_gender_on): ''' full process to extract face, ROI face detection and facial landmark run every 3 frames age and gender detection runs every 6 frames last values of detections are used in other frames to reduce the time of the process ***NOTE: need 2 time facial landmarks, 1 for face alignment and 1 for facial landmarks in aligned face ***TODO: find facial landmarks after rotate (find co-ords after rotating) so don't need to do 2 facial landmarks Args: frame (cv2 image): input frame type (str): 5 or 68 landmarks face_detect_on (bool): flag to run face detection and facial landmarks age_gender_on (bool): flag to run age gender detection Outputs: rects (array): detected faces as rectangles face (cv2 image): face (age, gender) (str,str): age and gender shape (array): facial landmarks' co-ords in format of tuples (x,y) aligned_face (cv2 image): face after alignment aligned_shape (array): facial landmarks' co-ords of the aligned face in format of tuples (x,y) #mask (cv2 image): mask of the face after fillConvexPoly ''' #assign from last params age = self.last_age gender = self.last_gender rects = self.last_rects shape = self.last_shape aligned_shape = self.last_aligned_shape gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) if face_detect_on: if(type=="5"): shape, rects = self.get_landmarks(frame, "5") #mask = None if shape is None: return None else: shape, rects = self.get_landmarks(frame, "68") # remapped_landmarks = self.facial_landmarks_remap(shape) # mask = np.zeros((face.shape[0], face.shape[1])) # cv2.fillConvexPoly(mask, remapped_landmarks[0:27], 1) if shape is None: return None (x, y, w, h) = face_utils.rect_to_bb(rects[0]) face = frame[y:y+h,x:x+w] if age_gender_on: age, gender = self.age_gender_detection(face) aligned_face, aligned_face = self.face_alignment(frame, shape) # if face_detect_on: # if(type=="5"): # aligned_shape, rects_2 = self.get_landmarks(aligned_face, "5") # if aligned_shape is None: # return None # else: # aligned_shape, rects_2 = self.get_landmarks(aligned_face, "68") # if aligned_shape is None: # return None # print("2: aligned_shape") # print(aligned_shape) # print("---") #assign to last params self.last_age = age self.last_gender = gender self.last_rects = rects self.last_shape = shape self.last_aligned_shape = aligned_shape #return rects, face, (age, gender), shape, aligned_face, mask return rects, face, (age, gender), shape, aligned_face, aligned_shape
def run_cam(self, vs, sio): @sio.event def build_event(data): print('into build_face.py data is:' + data) self.input_name = data while True: frame = vs.read() frame_save = frame.copy() frame = imutils.resize(frame, width=600) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # detect faces in the grayscale frame rects = self.detector(gray, 0) if len(rects) > 0: text = "{} face(s) found".format(len(rects)) cv2.putText(frame, text, (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) for rect in rects: (bX, bY, bW, bH) = face_utils.rect_to_bb(rect) cv2.rectangle(frame, (bX, bY), (bX + bW, bY + bH), (0, 255, 0), 3) # determine the facial landmarks for the face region, then # convert the facial landmark (x, y)-coordinates to a NumPy # array shape = self.predictor(gray, rect) shape = face_utils.shape_to_np(shape) # loop over the (x, y)-coordinates for the facial landmarks # and draw each of them for (i, (x, y)) in enumerate(shape): cv2.circle(frame, (x, y), 3, (0, 0, 255), -1) cv2.putText(frame, str(i + 1), (x - 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 0, 255), 1) key = cv2.waitKey(100) & 0xFF name_flag = False if (self.input_name != 'q') and (self.input_name != ''): name_flag = True if key == ord("q"): break elif (len(rects) == 1) and (name_flag == True): lf = Load_face() cv2.imwrite('face_pic/{}.jpg'.format(self.input_name), frame_save) print('okay face in !') cv2.rectangle(frame, (100, 50), (550, 110), (0, 255, 0), -1) text = "okay face in !" cv2.putText(frame, text, (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 0, 0), 3) # cv2.imshow("Video", frame) self.to_base64_send(frame, 'stream_event', sio) key = cv2.waitKey(100) & 0xFF lf.load_json() lf.update(self.input_name) lf.to_json() time.sleep(3) break # cv2.imshow("Video", frame) self.to_base64_send(frame, 'stream_event', sio)
def align(self, image_name, face_loc=None): image = cv2.imread(self.image_path + image_name) image = imutils.resize(image, width=800) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if (face_loc == None): rects = self.detector(gray, 2) else: rects = [ dlib.rectangle(face_loc[0], face_loc[3], face_loc[1], face_loc[2]) ] print(rects) # loop over the face detections for c, rect in enumerate(rects): # extract the ROI of the *original* face, then align the face # using facial landmarks (x, y, w, h) = rect_to_bb(rect) faceOrig = imutils.resize(image[y:y + h, x:x + w], width=256) # convert the landmark (x, y)-coordinates to a NumPy array shape = self.predictor(gray, rect) shape = shape_to_np(shape) # extract the left and right eye (x, y)-coordinates (lStart, lEnd) = self.FACIAL_LANDMARKS_IDXS["left_eye"] (rStart, rEnd) = self.FACIAL_LANDMARKS_IDXS["right_eye"] leftEyePts = shape[lStart:lEnd] rightEyePts = shape[rStart:rEnd] # compute leftEyeCenter = leftEyePts.mean(axis=0).astype("int") rightEyeCenter = rightEyePts.mean(axis=0).astype("int") # compute the angle between the eye centroids dY = rightEyeCenter[1] - leftEyeCenter[1] dX = rightEyeCenter[0] - leftEyeCenter[0] angle = np.degrees(np.arctan2(dY, dX)) - 180 # compute the desired right eye x-coordinate based on the # desired x-coordinate of the left eye desiredRightEyeX = 1.0 - self.desiredLeftEye[0] # determine the scale of the new resulting image by taking # the ratio of the distance between eyes in the *current* # image to the ratio of distance between eyes in the # *desired* image dist = np.sqrt((dX**2) + (dY**2)) desiredDist = (desiredRightEyeX - self.desiredLeftEye[0]) desiredDist *= self.desiredFaceWidth scale = desiredDist / dist # compute center (x, y)-coordinates (i.e., the median point) # between the two eyes in the input image eyesCenter = ((leftEyeCenter[0] + rightEyeCenter[0]) // 2, (leftEyeCenter[1] + rightEyeCenter[1]) // 2) # grab the rotation matrix for rotating and scaling the face M = cv2.getRotationMatrix2D(eyesCenter, angle, scale) # update the translation component of the matrix tX = self.desiredFaceWidth * 0.5 tY = self.desiredFaceHeight * self.desiredLeftEye[1] M[0, 2] += (tX - eyesCenter[0]) M[1, 2] += (tY - eyesCenter[1]) # apply the affine transformation (w, h) = (self.desiredFaceWidth, self.desiredFaceHeight) output = cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC) # apply the affine transformation (w, h) = (self.desiredFaceWidth, self.desiredFaceHeight) output = cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC) print(img_name + " was aligned.") cv2.imwrite('../data/aligned/' + 'aligned_' + str(c) + img_name, output) return
def display_front_frame(self, frame, prediction_results): """ Display frame on cv2 window. Args: frame (?): cv2 frame. prediction_results (list): a list of tuples. Each item corresponds to a face and has (face_rect, age, gender). """ if frame is None: return height, width = frame.shape[:2] img_ratio = float(height) / float(width) w_scale_factor = float(width) / float(predictor.PROCESSING_SIZE) h_scale_factor = float(height) / (predictor.PROCESSING_SIZE * img_ratio) # write the last person id cv2.putText(frame, str(self._last_id) + ' - ' + str(len(prediction_results)), (10, 25), cv2.FONT_HERSHEY_DUPLEX, 1.0, (0, 0, 0), 1) if len(prediction_results) > 0: # write the results on the frame for face_rect, _, age_gender_probas in prediction_results: # convert dlib.rectangle to regular bounding box (x, y, w, h) = rect_to_bb(face_rect) # re-scale based on predictor.PROCESSING_SIZE x = int(x * w_scale_factor) y = int(y * h_scale_factor) w = int(w * w_scale_factor) h = int(h * h_scale_factor) # draw rectangle on the frame cv2.rectangle(frame, (x, y), (x + w, y + h), (179, 178, 179), 2) # draw a filled rectangle to write text cv2.rectangle(frame, (x, y + h - 35), (x + w, y + h), (212, 211, 212), cv2.FILLED) # write age and gender if provided if not age_gender_probas is None: index = np.argmax(age_gender_probas) text = '' if index == 0: text = 'child' elif index == 1: text = 'M adult' elif index == 2: text = 'F adult' elif index == 3: text = 'senior' else: print("Age / gender out of range.") cv2.putText(frame, text, (x + 2, y + h - 6), cv2.FONT_HERSHEY_DUPLEX, 1.0, (0, 0, 0), 1) # display the frame cv2.namedWindow('Front Camera', cv2.WINDOW_NORMAL) cv2.resizeWindow('Front Camera', predictor.PROCESSING_SIZE, int(img_ratio * predictor.PROCESSING_SIZE)) cv2.imshow('Front Camera', frame)
print('LastNameEN') print(pytesseract.image_to_string(roiLastNameEN, lang = 'eng',config=tessdata_dir_config)) id_card = pytesseract.image_to_string(roiID, lang = 'eng',config=tessdata_dir_config) nameTH = pytesseract.image_to_string(roiNameTH, lang = 'tha',config=tessdata_dir_config) nameEng = pytesseract.image_to_string(roiNameEN, lang = 'eng',config=tessdata_dir_config) lastNameEng = pytesseract.image_to_string(roiLastNameEN, lang = 'eng',config=tessdata_dir_config) timestr = time.strftime("%d_%m_%Y-%H_%M_%S") #detect face rects = detector(gray_image,1) if len(rects) == 0: print "Don't have any face" else: for(i, rect) in enumerate(rects): (xf, yf, wf, hf) = face_utils.rect_to_bb(rect) cv2.rectangle(roiImg,(xf,yf),(xf+wf,yf+hf),(0,255,0),2) roiface = image[yf:yf+hf,xf:xf+wf] f = open('data.txt','a') f.write("\nID : "+id_card.encode('utf8')+"\n") f.write("Thai Name : "+nameTH.encode('utf8')+"\n") f.write("Name : "+nameEng.encode('utf8')+"\n") f.write("Last Name : "+lastNameEng.encode('utf8')+"\n") f.write ("Image : "+timestr+".jpg"+"\n") f.write("\n") cv2.imwrite(timestr+".jpg", roiImg) f.close() cv2.imshow('roiface',roiface)
def get_frame(self): pickle_in = open("New_testing_dlib_normalized.pickle", "rb") model = pickle.load(pickle_in) while (self.video.isOpened()): self.frame += 1 ret, frame = self.video.read() if ret is True: if self.frame % 5 == 0: # print(str(self.frame)+" frame") #ret, frame = self.video.read() # if ret == True: self.frame += 1 gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) file = open("Expressions.csv", "w") face = detector(gray, 0) # print("Number of Faces {}".format(len(face))) my_list = [] count_interested = 0 count_bore = 0 count_neutral = 0 for (J, rect) in enumerate(face): shap = predictor(frame, rect) xlist = [] ylist = [] shap = face_utils.shape_to_np(shap) Centre = (shap[30]) centre_x = Centre[0] centre_y = Centre[1] shap = shap[18:68] for i in shap: xlist.append(i[0]) ylist.append(i[1]) forx = [] fory = [] for x in xlist: forx.append((x - centre_x)**2) for y in ylist: fory.append((y - centre_y)**2) listsum = [sum(x) for x in zip(forx, fory)] features = [] for i in listsum: k = mpmath.sqrt(float(i)) features.append(float(k)) maxx = (max(features)) final = [] for i in features: if (i == 0.0): continue F = i / maxx final.append(F) # print(final) numpy_array = np.array(final) prediction = model.predict([numpy_array])[0] # print(prediction) # print("done") (x, y, w, h) = face_utils.rect_to_bb(rect) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2) # display the image and the prediction cv2.putText(frame, prediction, (x - 7, y - 6), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0), 2) cv2.circle(frame, (centre_x, centre_y), 1, (0, 0, 0), 10) for (x, y) in shap: cv2.circle(frame, (x, y), 1, (0, 0, 255), 2) cv2.line(frame, (centre_x, centre_y), (x, y), (0, 255, 1)) cv2.waitKey(100) if prediction == "INTERESTED": count_interested += 1 # self.Expression.append(1) elif prediction == "BORE": count_bore += 1 else: count_neutral += 1 ret, jpeg = cv2.imencode('.jpg', frame) my_list.append(jpeg.tobytes) if (count_interested > count_bore) and (count_interested > count_neutral): self.Expression.append(1) elif (count_bore > count_interested) and (count_bore > count_neutral): self.Expression.append(-1) else: self.Expression.append(0) with file: writter = csv.writer(file) writter.writerow(self.Expression) return (my_list) else: break
writer = imageio.get_writer(args['output_name'] + '.mp4', fps=20.0) # prompt the user if the face found is a good detection face_dets = detector(f, 1) cut = None mask = None face_pts = None while True: if len(face_dets) == 0: ret, f = cap_f.read() face_dets = detector(f, 1) continue for (i, face) in enumerate(face_dets): # face = face.rect f_show = copy.deepcopy(f) (x, y, w, h) = face_utils.rect_to_bb(face) cv2.rectangle(f_show, (x, y), (x + w, y + h), (0, 255, 0), 2) shape = predictor(f, face) shape = face_utils.shape_to_np(shape) for (xs, ys) in shape: cv2.circle(f_show, (xs, ys), 1, (0, 0, 255), -1) cv2.putText(f_show, 'Press s to select current face', (30, 30), font, 1, (255, 255, 255), 2, cv2.LINE_AA) cv2.putText(f_show, 'Press d to detect again', (30, 60), font, 1, (255, 255, 255), 2, cv2.LINE_AA) winname = 'Faces' cv2.namedWindow(winname, cv2.WINDOW_NORMAL) cv2.moveWindow(winname, 400, 500) cv2.imshow(winname, f_show) k = cv2.waitKey(0) if k == 115:
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) ####>> rects = self.detector(gray, 2) ####~>>>>>>>>>> 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 ########>>>>>>>> for rect in rects: (x, y, w, h) = rect_to_bb(rect) faceAligned = self.fa.align(frame, gray, rect) cv2.imwrite("Img" + str(i) + ".png", faceAligned) faceAligned = cv2.cvtColor(faceAligned, cv2.COLOR_BGR2RGB) arr = np.reshape(faceAligned, (1, 100, 100, 3)) arr = arr.astype(np.float) #############>>>>>>> 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() ##########>>>>>>>>>>>> pd = self.model_ethinicity.predict(arr) race = self.array[np.asscalar(pd.argmax(axis=1))] #########>>>> ##########>>>>> frontal_faces = sorted(faces, reverse=True, key=lambda x: (x[2] - x[0]) * (x[3] - x[1]))[0] (fX, fY, fW, fH) = frontal_faces roi = gray[fY:fY + fH, fX:fX + fW] roi = cv2.resize(roi, (48, 48)) roi = roi.astype("float") / 255.0 roi = img_to_array(roi) roi = np.expand_dims(roi, axis=0) np.reshape(roi, (48, 48, 1)) preds = self.emotion_classifier.predict(roi)[0] emotion_probability = np.max(preds) emotion = self.EMOTIONS[preds.argmax()] ########>>>>>>>> # draw results for i, face in enumerate(faces): label = "{}, {} , {},{}".format( emotion, race, 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()
def face_detect(self, frame): #frame = imutils.resize(frame, width=400) face_frame = np.zeros((10, 10, 3), np.uint8) mask = np.zeros((10, 10, 3), np.uint8) ROI1 = np.zeros((10, 10, 3), np.uint8) ROI2 = np.zeros((10, 10, 3), np.uint8) #ROI3 = np.zeros((10, 10, 3), np.uint8) status = False if frame is None: return gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # detect faces in the grayscale image rects = self.detector(gray, 0) # loop over the face detections #for (i, rect) in enumerate(rects): # determine the facial landmarks for the face region, then # convert the facial landmark (x, y)-coordinates to a NumPy # array #assumpion: only 1 face is detected if len(rects)>0: status = True # shape = self.predictor(gray, rects[0]) # shape = face_utils.shape_to_np(shape) # convert dlib's rectangle to a OpenCV-style bounding box # [i.e., (x, y, w, h)], then draw the face bounding box (x, y, w, h) = face_utils.rect_to_bb(rects[0]) #cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 1) if y<0: print("a") return frame, face_frame, ROI1, ROI2, status, mask #if i==0: face_frame = frame[y:y+h,x:x+w] # show the face number #cv2.putText(frame, "Face #{}".format(i + 1), (x - 10, y - 10), # cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) # loop over the (x, y)-coordinates for the facial landmarks # and draw them on the image # for (x, y) in shape: # cv2.circle(frame, (x, y), 1, (0, 0, 255), -1) #draw facial landmarks if(face_frame.shape[:2][1] != 0): face_frame = imutils.resize(face_frame,width=256) face_frame = self.fa.align(frame,gray,rects[0]) # align face grayf = cv2.cvtColor(face_frame, cv2.COLOR_BGR2GRAY) rectsf = self.detector(grayf, 0) if len(rectsf) >0: shape = self.predictor(grayf, rectsf[0]) shape = face_utils.shape_to_np(shape) for (a, b) in shape: cv2.circle(face_frame, (a, b), 1, (0, 0, 255), -1) #draw facial landmarks cv2.rectangle(face_frame,(shape[54][0], shape[29][1]), #draw rectangle on right and left cheeks (shape[12][0],shape[33][1]), (0,255,0), 0) cv2.rectangle(face_frame, (shape[4][0], shape[29][1]), (shape[48][0],shape[33][1]), (0,255,0), 0) ROI1 = face_frame[shape[29][1]:shape[33][1], #right cheek shape[54][0]:shape[12][0]] ROI2 = face_frame[shape[29][1]:shape[33][1], #left cheek shape[4][0]:shape[48][0]] # ROI3 = face_frame[shape[29][1]:shape[33][1], #nose # shape[31][0]:shape[35][0]] #get the shape of face for color amplification rshape = np.zeros_like(shape) rshape = self.face_remap(shape) mask = np.zeros((face_frame.shape[0], face_frame.shape[1])) cv2.fillConvexPoly(mask, rshape[0:27], 1) # mask = np.zeros((face_frame.shape[0], face_frame.shape[1],3),np.uint8) # cv2.fillConvexPoly(mask, shape, 1) #cv2.imshow("face align", face_frame) # cv2.rectangle(frame,(shape[54][0], shape[29][1]), #draw rectangle on right and left cheeks # (shape[12][0],shape[54][1]), (0,255,0), 0) # cv2.rectangle(frame, (shape[4][0], shape[29][1]), # (shape[48][0],shape[48][1]), (0,255,0), 0) # ROI1 = frame[shape[29][1]:shape[54][1], #right cheek # shape[54][0]:shape[12][0]] # ROI2 = frame[shape[29][1]:shape[54][1], #left cheek # shape[4][0]:shape[48][0]] else: cv2.putText(frame, "No face detected", (200,200), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 255),2) status = False return frame, face_frame, ROI1, ROI2, status, mask
def eye_blink_cam(self, frame, rect, detector, predictor, COUNTER, TOTAL, ear_top): eyes_detect = '' # resize del frame a width a 450 frame = imutils.resize(frame, width=450) # conversione in scala di grigi gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) dets = detector(gray, 1) # Detect the faces in the image (left_s, left_e) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"] (right_s, right_e) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"] # andiamo a rilevare il rettangolo del volto e croppiamo l'immagine con 200x200 for det in dets: (x, y, w, h) = face_utils.rect_to_bb(det) crop = gray[y:y + h, x:x + w] try: crop = cv2.resize(crop, (DIMENSION, DIMENSION)) except Exception as e: print(str(e)) break dets1 = detector(crop, 1) # rilevamento degli occhi e calcolo dell'EAR di entrambe gli occhi for det in dets1: shape = predictor(crop, det) shape = face_utils.shape_to_np(shape) leftEye = shape[left_s:left_e] rightEye = shape[right_s:right_e] left_eye_EAR = self.eye_aspect_ratio(leftEye) right_eye_EAR = self.eye_aspect_ratio(rightEye) ear = (left_eye_EAR + right_eye_EAR) / 2.0 # se ear_top è già stato assegnato allora viene calcolato il threshold if ear_top != 0: ear_threshold = (ear_top * 2) / 3 print("Ear_th", ear_threshold) print("EAR TOP", ear_top) # se ear < del suo threshold if ear < ear_threshold: # abbiamo lo stato di occhi chiusi e incrementiamo il contatore dei frame eyes_detect = '1' COUNTER += 1 else: # quando l'occhio è aperto o di nuovo aperto, andiamo a confrontare il contatore # se ha raggiunto i minimi frame consecutivi e se lo è abbiamo avuto un eyeblink # di conseguenza il contatore viene azzerato. eyes_detect = '0' if COUNTER >= CONSEC_FRAMES_NUMBER: TOTAL += 1 COUNTER = 0 cv2.putText(frame, "Blinks: {}".format(TOTAL), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) # ear è maggiore di ear_top lo sostituisce, ricordo che ear_top ad inizio video è a 0 e serve per # calcolare il threshold if ear > ear_top: ear_top = ear return eyes_detect, TOTAL, COUNTER, ear_top
# for l in landmrk: # for key,val in l.items(): # for (x,y) in val: # cv2.circle(frame, (x, y), 1, (255,0, 0), -1) gray_image = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) faces = detector(rgb_image) # face_locations = face_recognition.face_locations(rgb_image) # print (reversed(face_locations)) face_name = face_compare(rgb_image,process_this_frame) for face_coordinates, fname in zip(faces,face_name): print ("forrrrr") x1, x2, y1, y2 = apply_offsets(face_utils.rect_to_bb(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, True) gray_face = np.expand_dims(gray_face, 0) gray_face = np.expand_dims(gray_face, -1) emotion_prediction = emotion_classifier.predict(gray_face) emotion_probability = np.max(emotion_prediction) emotion_label_arg = np.argmax(emotion_prediction) emotion_text = emotion_labels[emotion_label_arg] emotion_window.append(emotion_text)
def eye_blink_video_fixedTh(self, frame, detector, predictor, COUNTER, TOTAL, ear_th): eyes_detect = '' rects = detector(frame, 1) # Detect the faces in the image (left_s, left_e) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"] (right_s, right_e) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"] # andiamo a rilevare il rettangolo del volto e croppiamo l'immagine (200x200) for rect in rects: (x, y, w, h) = face_utils.rect_to_bb(rect) crop = frame[y:y + h, x:x + w] try: crop = cv2.resize(crop, (DIMENSION, DIMENSION)) except Exception as e: print(str(e)) break rects1 = detector(crop, 1) for rect in rects1: shape = predictor(crop, rect) shape = face_utils.shape_to_np(shape) # rilevamento degli occhi e calcolo dell'EAR di entrambe gli occhi leftEye = shape[left_s:left_e] rightEye = shape[right_s:right_e] left_eye_EAR = self.eye_aspect_ratio(leftEye) right_eye_EAR = self.eye_aspect_ratio(rightEye) ear = (left_eye_EAR + right_eye_EAR) / 2.0 leftEyeHull = cv2.convexHull(leftEye) rightEyeHull = cv2.convexHull(rightEye) cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1) cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1) # confrontiamo EAR con i threshold che vanno da 0.10 a 0.29 e mettiamo 1 al relavito threshold se EAR è # minore di esso altrimenti il valore resta a 0. count = 0 for threshold in np.arange(0.10, 0.30, 0.01): th = np.round(threshold, 2) if ear < th: COUNTER += 1 eyes_detect = '1' ear_th[count] = 1 else: eyes_detect = '0' COUNTER = 0 count += 1 # print(count) cv2.putText(frame, "Blinks: {}".format(TOTAL), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) cv2.putText(frame, "EAR: {:.2f}".format(ear), (200, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) cv2.imshow('Frame', frame) cv2.waitKey(1) return eyes_detect, COUNTER, ear_th
def alignFace(frame, gray, rect, aligner): (x, y, w, h) = face_utils.rect_to_bb(rect) faceOrig = imutils.resize(frame[y:y + h, x:x + w], width=256) faceAligned = aligner.align(frame, gray, rect) return faceOrig, faceAligned
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # detect faces in the grayscale frame rects = detector(gray, 0) # check to see if a face was detected, and if so, draw the total # number of faces on the frame if len(rects) > 0: text = "{} face(s) found".format(len(rects)) cv2.putText(frame, text, (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) # loop over the face detections for rect in rects: # compute the bounding box of the face and draw it on the # frame (bX, bY, bW, bH) = face_utils.rect_to_bb(rect) cv2.rectangle(frame, (bX, bY), (bX + bW, bY + bH), (0, 255, 0), 1) shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape)[indices] shape = np.array([tuple(i) for i in shape], dtype="double") image_points = shape #print(type(shape), shape) rotation_vector, translation_vector = get_rotation( shape, model_points, camera_matrix) (nose_end_point2D, jacobian) = cv2.projectPoints(np.array([(0.0, 0.0, 1000.0)]), rotation_vector, translation_vector, camera_matrix, dist_coeffs) print('projected') #for p in image_points:
def face_detect(self, frame): #frame = imutils.resize(frame, width=400) face_frame = np.zeros((10, 10, 3), np.uint8) mask = np.zeros((10, 10, 3), np.uint8) ROI1 = np.zeros((10, 10, 3), np.uint8) ROI2 = np.zeros((10, 10, 3), np.uint8) status = False if frame is None: return rgb_frame = frame[:, :, ::-1] # detect faces in the rgb image rects = api.face_detector(rgb_frame) if len(rects)>0: status = True (x, y, w, h) = face_utils.rect_to_bb(rects[0]) if y<0: print("a") return frame, face_frame, ROI1, ROI2, status, mask face_frame = frame[y:y+h,x:x+w] if(face_frame.shape[:2][1] != 0): face_frame = imutils.resize(face_frame,width=256) face_frame = self.fa.align(frame,rgb_frame,rects[0]) rgb_frame_f = face_frame[:, :, ::-1] rectsf = api.face_detector(rgb_frame_f) if len(rectsf) >0: shape = self.predictor(rgb_frame_f, rectsf[0]) shape = face_utils.shape_to_np(shape) for (a, b) in shape: cv2.circle(face_frame, (a, b), 1, (0, 0, 255), -1) #draw facial landmarks cv2.rectangle(frame, (x, y), (w + x, h + y), (0, 0, 255), 1) cv2.rectangle(face_frame,(shape[54][0], shape[29][1]), #draw rectangle on right and left cheeks (shape[12][0],shape[33][1]), (0,255,0), 0) cv2.rectangle(face_frame, (shape[4][0], shape[29][1]), (shape[48][0],shape[33][1]), (0,255,0), 0) ROI1 = face_frame[shape[29][1]:shape[33][1], #right cheek shape[54][0]:shape[12][0]] ROI2 = face_frame[shape[29][1]:shape[33][1], #left cheek shape[4][0]:shape[48][0]] rshape = np.zeros_like(shape) rshape = self.face_remap(shape) mask = np.zeros((face_frame.shape[0], face_frame.shape[1])) cv2.fillConvexPoly(mask, rshape[0:27], 1) else: cv2.putText(frame, "No face detected", (200,200), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 255),2) status = False frame = cv2.resize(frame, (640, 480)) return frame, face_frame, ROI1, ROI2, status, mask
def upload_file(): file = request.files['image'] image_path = os.path.sep.join([UPLOAD_FOLDER, file.filename]) file.save(image_path) # image_url = uploader.upload(image_path) # image = AgeGenderHelper.url_to_image(image_url['url']) # initialize dlib's face detector (HOG-based), then create facial landmark predictor and face aligner detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(deploy.DLIB_LANDMARK_PATH) fa = FaceAligner(predictor) # initialize image preprocessors sp, cp, iap = SimplePreprocessor( 256, 256, inter=cv2.INTER_CUBIC), CropPreprocessor( config.IMAGE_SIZE, config.IMAGE_SIZE, horiz=False), ImageToArrayPreprocessor() # loop over image paths # load image fron disk, resize it and convert it to grayscale print(f'[INFO] processing {file.filename}') image = cv2.imread(image_path) image = imutils.resize(image, width=1024) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) clone = image.copy() # detect faces in grayscale image rects = detector(gray, 1) # loop over face detections for rect in rects: # determine facial landmarks for face region, then align face shape = predictor(gray, rect) face = fa.align(image, gray, rect) # draw bounding box around face x, y, w, h = face_utils.rect_to_bb(rect) cv2.rectangle(clone, (x, y), (x + w, y + h), (0, 255, 0), 2) if config.DATASET == 'IOG': # load Label Encoder and mean files print('[INFO] loading label encoders and mean files...') age_le = pickle.loads(open(deploy.AGE_LABEL_ENCODER, 'rb').read()) gender_le = pickle.loads( open(deploy.GENDER_LABEL_ENCODER, 'rb').read()) age_means = json.loads(open(deploy.AGE_MEAN).read()) gender_means = json.loads(open(deploy.GENDER_MEAN).read()) # initialize image preprocessors age_mp = MeanPreprocessor(age_means['R'], age_means['G'], age_means['B']) gender_mp = MeanPreprocessor(gender_means['R'], gender_means['G'], gender_means['B']) age_preds, gender_preds = predict(face, sp, age_mp, gender_mp, cp, iap, deploy.AGE_NETWORK_PATH, deploy.GENDER_NETWORK_PATH, age_le, gender_le) elif config.DATASET == 'ADIENCE': # age_preds_cross, gender_preds_cross = [], [] i = 0 # load Label Encoder and mean files print( f'[INFO] loading label encoders and mean files for cross validation {i}...' ) age_le = pickle.loads( open(deploy.AGE_LABEL_ENCODERS[i], 'rb').read()) gender_le = pickle.loads( open(deploy.GENDER_LABEL_ENCODERS[i], 'rb').read()) age_means = json.loads(open(deploy.AGE_MEANS[i]).read()) gender_means = json.loads(open(deploy.GENDER_MEANS[i]).read()) # initialize image preprocessors age_mp = MeanPreprocessor(age_means['R'], age_means['G'], age_means['B']) gender_mp = MeanPreprocessor(gender_means['R'], gender_means['G'], gender_means['B']) age_preds, gender_preds = predict(face, sp, age_mp, gender_mp, cp, iap, deploy.AGE_NETWORK_PATHS[i], deploy.GENDER_NETWORK_PATHS[i], age_le, gender_le) # age_preds_cross.append(age_pred) # gender_preds_cross.append(gender_pred) # age_preds, gender_preds = np.mean(age_preds_cross, axis = 0), np.mean(gender_preds_cross, axis = 0) clone = AgeGenderHelper.visualize_video(age_preds, gender_preds, age_le, gender_le, clone, (x, y)) # path = image_path.split('.') # pred_path = '.'.join([f'{path[0]}_predict', path[1]]) # pred_filename = pred_path.split(os.path.sep)[-1] pred_path = '.'.join([f"{image_path.split('.')[0]}_1", 'jpg']) cv2.imwrite(pred_path, clone) # image_url = uploader.upload(pred_path) gc.collect() K.clear_session() return render_template('index.html', filename=pred_path.split(os.path.sep)[-1])
def register_yourself(student_id, frame_num, image_num, id_idx): try: os.makedirs(DATA_PATH) except: pass #Loading the stored face encodings and corresponding IDs try: with open(os.path.join(STORAGE_PATH, "known_face_ids.pickle"), "rb") as fp: known_face_ids = pickle.load(fp) with open(os.path.join(STORAGE_PATH, "known_face_encodings.pickle"), "rb") as fp: known_face_encodings = pickle.load(fp) except: known_face_encodings = [] known_face_ids = [] mpl.rcParams['toolbar'] = 'None' print("[INFO] Loading Face Detector") detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(LANDMARK_PATH) fa = FaceAligner(predictor, desiredFaceWidth=96) print("[INFO] Initializing Video stream") vs = cv2.VideoCapture(0) #,cv2.CAP_DSHOW) #Uncommnet below to create the folder for the images ''' IMAGE_PATH = os.path.join(DATA_PATH, student_id) try: os.makedirs(IMAGE_PATH) except: pass ''' #Entry time tin = time.time() #frame = vs.read() #fig = plt.figure() #plot = plt.subplot(1,1,1) #plt.title("Detecting Face") #plt.axis('off') #im1 = plot.imshow(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) while image_num < 10: # Take 10 images _, frame = vs.read() frame_num += 1 #Resize each image #frame = cv2.resize(frame ,(600,600)) #Applying face enhancement steps frame = imageEnhancement.adjust_gamma(frame, gamma=1.5) gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #Detecting faces in the frame faces = detector(gray_frame, 0) for face in faces: if face is None: print("face is none") continue #Capture the face and align it using the face aligner (x, y, w, h) = rect_to_bb(face) face_aligned = fa.align(frame, gray_frame, face) face_aligned = cv2.resize(face_aligned, (600, 600)) # @params the initial point of the rectangle will be x,y and # @params end point will be x+width and y+height # @params along with color of the rectangle # @params thickness of the rectangle #Put a bounding box over detected face frame = cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 1) #cv2.imshow("Image Captured",frame) #cv2.waitKey(50) #plt.ion() #im1.set_data(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) #plt.pause(0.001) #plt.show() if (frame_num % 30 == 0): #Uncommnet the line below to store the face images #cv2.imwrite(IMAGE_PATH + "/{}_".format(student_id) + str(j) + ".jpg", face_aligned) #Appending the face encodings and corresponding IDs try: known_face_encodings.append( face_recognition.face_encodings(frame)[0]) known_face_ids.append(student_id) except: continue image_num += 1 #OpenCV's implementation to show an image in window(doesn't work on production server) #cv2.imshow("Capturing Images for registration (PRESS Q TO QUIT",frame) #Encoding the frame to be stream into browser frame = cv2.imencode('.jpg', frame)[1].tobytes() yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n') #if(cv2.waitKey(1) == ord("q")): # break #Storing the face encodings and corresponding IDs to disk with open(os.path.join(STORAGE_PATH, "known_face_ids.pickle"), "wb") as fp: pickle.dump(known_face_ids, fp) with open(os.path.join(STORAGE_PATH, "known_face_encodings.pickle"), "wb") as fp: pickle.dump(known_face_encodings, fp) #Noting the number of pictures already captured and storing the index id_idx[student_id] = image_num with open(os.path.join(STORAGE_PATH, "id_idx.json"), "w") as outfile: json.dump(id_idx, outfile) #Exit time tout = time.time() print(tout - tin) #plt.close() #Releasing the videostream vs.release() cv2.destroyAllWindows() return True
def analyze(img): outputArray = [] detector = dlib.get_frontal_face_detector() predictor_path = 'shape_predictor_68_face_landmarks.dat' predictor = dlib.shape_predictor(predictor_path) image = cv2.imread(img) image = imutils.resize(image, width=500) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) rects = detector(gray, 1) for (i, rect) in enumerate(rects): # determine the facial landmarks for the face region, then # convert the facial landmark (x, y)-coordinates to a NumPy # array shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) # convert dlib's rectangle to a OpenCV-style bounding box # [i.e., (x, y, w, h)], then draw the face bounding box (x, y, w, h) = face_utils.rect_to_bb(rect) cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2) # show the face number cv2.putText(image, "Face #{}".format(i + 1), (x - 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) # loop over the (x, y)-coordinates for the facial landmarks # and draw them on the image index = 1 coordsArray = [] for (x, y) in shape: # print("Point: " + str(index) + " " + # "x: " + str(x) + " ,y: " + str(y)) index += 1 coords = tuple([x, y]) coordsArray.append(coords) cv2.circle(image, (x, y), 1, (0, 0, 255), -1) distances = [((x1 - x2)**2 + (y1 - y2)**2)**0.5 for (x1, y1) in coordsArray for (x2, y2) in coordsArray] sum_of_distances = sum(x1 / x2 for x1 in distances for x2 in distances if x1 != x2 and x2 != 0) point_37 = coordsArray[36] point_40 = coordsArray[39] left_eye_length = ((point_37[0] - point_40[0])**2 + (point_37[1] - point_40[1])**2)**0.5 print(f"Left eye length is: {left_eye_length}") right_eye_length = calc_distance(coordsArray, 43, 46) eye_distance = calc_distance(coordsArray, 40, 43) nose_length = calc_distance(coordsArray, 28, 34) left_eyebrow = calc_distance(coordsArray, 18, 22) right_eyebrow = calc_distance(coordsArray, 23, 27) mouth_length = calc_distance(coordsArray, 49, 55) print(f"Right eye length is: {right_eye_length}") print(f"Distance between eyes: {eye_distance}") print(f"Nose length is: {nose_length}") print(f"Left eyebrow is: {left_eyebrow}") print(f"Right eyebrow is: {right_eyebrow}") print(f"Nose length is: {nose_length}") print(f"Mouth length is: {mouth_length}") score = sum_of_distances / 1000000 print(score) outputArray.append(score) outputArray.append(right_eye_length) outputArray.append(left_eye_length) outputArray.append(eye_distance) outputArray.append(right_eyebrow) outputArray.append(left_eyebrow) outputArray.append(nose_length) outputArray.append(mouth_length) # return cv2.imshow("Output", image) print(outputArray) image = Image.fromarray(image) buff = BytesIO() image.save(buff, format="JPEG") img_str = base64.b64encode(buff.getvalue()) if not outputArray: return "Could not process image" else: return json.dumps({'photo': str(img_str), 'data': outputArray})
if len(rects) == 1: face_rect = rects[0] force_detect_face = False # we have got an face rect if not force_detect_face: # detect the face and the landmarks shape_array = face_utils.shape_to_np( predictor(image, face_rect)) # ndarray (68, 2) lip_array = shape_array[48:68] # mouth index [48: 68) # get the bounds of landmarks (shape_x, shape_y, shape_w, shape_h) = cv2.boundingRect(shape_array) # new face region (mouth_x, mouth_y, mouth_w, mouth_h) = cv2.boundingRect(lip_array) # mouth region (face_x, face_y, face_w, face_h) = face_utils.rect_to_bb(face_rect) # last face region # first use gap_feature to check is the user is speaking # gap_distance: mean distance between lip inner points gap_distance = ( math.hypot(lip_array[13][0] - lip_array[19][0], lip_array[13][1] - lip_array[19][1]) + math.hypot(lip_array[14][0] - lip_array[18][0], lip_array[14][1] - lip_array[18][1]) + math.hypot(lip_array[15][0] - lip_array[17][0], lip_array[15][1] - lip_array[17][1])) / 3 # width_distance: mean distance between lip inner corner points width_distance = math.hypot( lip_array[12][0] - lip_array[16][0], lip_array[12][1] - lip_array[16][1]) # use their ratio to detect if is speaking or not
def bpmrpm(): count = 0 rates = [] video = True if video == False: cap = cv2.VideoCapture(0) else: cap = cv2.VideoCapture("video.webm") fu = Face_utilities() sp = Signal_processing() i=0 last_rects = None last_shape = None last_age = None last_gender = None face_detect_on = False age_gender_on = False t = time.time() #for signal_processing BUFFER_SIZE = 100 fps=0 #for real time capture video_fps = cap.get(cv2.CAP_PROP_FPS) # for video capture #print(video_fps) times = [] data_buffer = [] # data for plotting filtered_data = [] fft_of_interest = [] freqs_of_interest = [] bpm = 0 #plotting app = QtGui.QApplication([]) win = pg.GraphicsWindow(title="plotting") p1 = win.addPlot(title="FFT") p2 = win.addPlot(title ="Signal") win.resize(1200,600) def update(): p1.clear() p1.plot(np.column_stack((freqs_of_interest,fft_of_interest)), pen = 'g') p2.clear() p2.plot(filtered_data[20:],pen='g') app.processEvents() timer = QtCore.QTimer() timer.timeout.connect(update) timer.start(300) while True: # grab a frame -> face detection -> crop the face -> 68 facial landmarks -> get mask from those landmarks # calculate time for each loop t0 = time.time() if(i%1==0): face_detect_on = True if(i%10==0): age_gender_on = True else: age_gender_on = False else: face_detect_on = False ret, frame = cap.read() #frame_copy = frame.copy() if frame is None: #print("End of video") cv2.destroyAllWindows() timer.stop() #sys.exit() break #display_frame, aligned_face = flow_process(frame) ret_process = fu.no_age_gender_face_process(frame, "68") if ret_process is None: cv2.putText(frame, "No face detected", (30,30), cv2.FONT_HERSHEY_SIMPLEX, 1,(0,0,255),2) cv2.imshow("frame",frame) #print(time.time()-t0) cv2.destroyWindow("face") if cv2.waitKey(1) & 0xFF == ord('q'): cv2.destroyAllWindows() timer.stop() #sys.exit() break continue rects, face, shape, aligned_face, aligned_shape = ret_process (x, y, w, h) = face_utils.rect_to_bb(rects[0]) cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2) #overlay_text = "%s, %s" % (gender, age) #cv2.putText(frame, overlay_text ,(x,y-15), cv2.FONT_HERSHEY_SIMPLEX, 1,(255,0,0),2,cv2.LINE_AA) if(len(aligned_shape)==68): cv2.rectangle(aligned_face,(aligned_shape[54][0], aligned_shape[29][1]), #draw rectangle on right and left cheeks (aligned_shape[12][0],aligned_shape[33][1]), (0,255,0), 0) cv2.rectangle(aligned_face, (aligned_shape[4][0], aligned_shape[29][1]), (aligned_shape[48][0],aligned_shape[33][1]), (0,255,0), 0) else: #print(shape[4][1]) #print(shape[2][1]) #print(int((shape[4][1] - shape[2][1]))) cv2.rectangle(aligned_face, (aligned_shape[0][0],int((aligned_shape[4][1] + aligned_shape[2][1])/2)), (aligned_shape[1][0],aligned_shape[4][1]), (0,255,0), 0) cv2.rectangle(aligned_face, (aligned_shape[2][0],int((aligned_shape[4][1] + aligned_shape[2][1])/2)), (aligned_shape[3][0],aligned_shape[4][1]), (0,255,0), 0) for (x, y) in aligned_shape: cv2.circle(aligned_face, (x, y), 1, (0, 0, 255), -1) #for signal_processing ROIs = fu.ROI_extraction(aligned_face, aligned_shape) green_val = sp.extract_color(ROIs) #print(green_val) data_buffer.append(green_val) if(video==False): times.append(time.time() - t) else: times.append((1.0/video_fps)*i) L = len(data_buffer) #print("buffer length: " + str(L)) if L > BUFFER_SIZE: data_buffer = data_buffer[-BUFFER_SIZE:] times = times[-BUFFER_SIZE:] #bpms = bpms[-BUFFER_SIZE//2:] L = BUFFER_SIZE #print(times) if L==100: fps = float(L) / (times[-1] - times[0]) cv2.putText(frame, "fps: {0:.2f}".format(fps), (30,int(frame.shape[0]*0.95)), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,0), 2) # detrended_data = sp.signal_detrending(data_buffer) #print(len(detrended_data)) #print(len(times)) interpolated_data = sp.interpolation(detrended_data, times) normalized_data = sp.normalization(interpolated_data) fft_of_interest, freqs_of_interest = sp.fft(normalized_data, fps) max_arg = np.argmax(fft_of_interest) bpm = freqs_of_interest[max_arg] cv2.putText(frame, "HR: {0:.2f}".format(bpm), (int(frame.shape[1]*0.8),int(frame.shape[0]*0.95)), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,0), 2) #print(detrended_data) filtered_data = sp.butter_bandpass_filter(interpolated_data, (bpm-20)/60, (bpm+20)/60, fps, order = 3) #print(fps) #filtered_data = sp.butter_bandpass_filter(interpolated_data, 0.8, 3, fps, order = 3) #write to txt file with open("a.txt",mode = "a+") as f: rates.append(bpm) f.write("time: {0:.4f} ".format(times[-1]) + ", HR: {0:.2f} ".format(bpm) + "\n") # display #cv2.imshow("mask",mask) i = i+1 #print("time of the loop number "+ str(i) +" : " + str(time.time()-t0)) count = count + 1 rates = [i for i in rates if i!=0] #print(rates) avg = sum(rates)/len(rates) resp = avg/4.5 print("Heart Rate: ",avg) print("Respiratory Rate: ", resp) l=[] l.append(avg) l.append(resp) return l
def main(): # return cap = cv2.VideoCapture(0) if not cap.isOpened(): print("Unable to connect to camera.") return counter = 0 frame_count = 0 record = False detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(face_landmark_path) fa = face_utils.FaceAligner(predictor, desiredFaceWidth=256) while cap.isOpened(): ret, img = cap.read() #flip img img = cv2.flip(img, 1) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) res = img.copy() if ret: #detect faces from image face_rects = detector(img, 0) for i in range(len(face_rects)): mask = np.zeros(img.shape[:2], dtype = np.uint8) #get face landmarks face_rect = face_rects[i] shape = predictor(img, face_rect) shape = face_utils.shape_to_np(shape) reprojectdst, euler_angle = get_head_pose(shape) #detect hull to crop face hull = cv2.convexHull(shape) cv2.fillPoly(mask, pts =[hull], color=1) #visualize cv2.polylines(res,[hull],True,(255, 0, 0)) for (x, y) in shape: cv2.circle(res, (x, y), 1, (0, 255, 0), -1) for start, end in line_pairs: cv2.line(res, reprojectdst[start], reprojectdst[end], (0, 0, 255)) (x, y, w, h) = face_utils.rect_to_bb(face_rect) x = np.clip(x, 0, img.shape[1]) y = np.clip(y, 0, img.shape[0]) w = np.clip(w, 1, img.shape[1]-x) h = np.clip(h, 1, img.shape[0]-y) img_masked = cv2.bitwise_and(img, img, mask = mask) faceOrig = cv2.resize(img_masked[y:y + h, x:x + w], (256, 256)) faceAligned = cv2.resize(fa.align(img_masked, gray, face_rect), (img.shape[1], img.shape[0])) if record: if frame_count % 2 == 0: path = './face_database/'+person_name+'/'+person_name+str(counter)+'.jpg' counter+=1 cv2.imwrite(path, faceAligned) res = np.hstack((res, faceAligned)) frame_count += 1 cv2.imshow("demo", res) key = cv2.waitKey(1) & 0xFF if key == ord('q'): break elif key == ord('r'): if not record: record = True print("recording...") else: record = False print("stop recording")
import cv2 import dlib from imutils import face_utils detector = dlib.get_frontal_face_detector() cap = cv2.VideoCapture("udpsrc port=5000 ! gdpdepay ! rtph264depay ! avdec_h264 ! videoconvert ! appsink sync=false") while True: f, frame = cap.read() dets = detector(frame, 1) for (i, face) in enumerate(dets): (x,y,w,h) = face_utils.rect_to_bb(face) cv2.rectangle(frame, (x,y), (x+w,y+h), (0,0,255), 2) cv2.imshow('cap', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()
import cv2 import numpy as np from imutils import face_utils as fu detect = dlib.get_frontal_face_detector() predict = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat') img = cv2.imread('test1.jpg') img = imutils.resize(img, width=500) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) rect = detect(gray, 1) # Face detections in the grayscale img for i, rct in enumerate(rect): shape = predict(gray, rct) shape = fu.shape_to_np(shape) x, y, w, h = fu.rect_to_bb(rct) cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 1) #roiColor = img[y:y +h, x:x + w] cv2.putText(img, "Face {}".format(i + 1), (x - 10, y - 10), cv2.FONT_HERSHEY_COMPLEX, 0.75, (0, 0, 255), 2) for x, y in shape: cv2.circle(img, (x, y), 1, (0, 255, 0), -1) #cv2.imshow('Crop Face', roiColor) cv2.imshow('Show Img', img) cv2.waitKey(0)