View difference between Paste ID: n9C0dDdE and RU26SNj3

 import os
 import cv2
 from flask import Flask, jsonify, request, render_template, Response, redirect, url_for
 from source.face_recognition import recognize_faces
 from source.utils import draw_rectangles, read_image, prepare_image
 from datetime import datetime
 from time import gmtime, strftime, localtime
 
 import pandas as pd
 # import the necessary packages
 from imutils.video import VideoStream
 from imutils.video import FPS
 import numpy as np
 import argparse
 import imutils
 from imutils import paths
 import pickle
 import time
 import cv2
 import os
 import csv
 from collections import defaultdict
 
 
 
 app = Flask(__name__)
 video = cv2.VideoCapture(0)
 
 app.config.from_object('config')
 UPLOAD_FOLDER = os.path.basename('uploads')
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 
 @app.route('/')
 def index():
     return render_template('index.html')
 
 @app.route('/realtime')
 def realtime():
     return render_template('realtime.html')
 
 def gen(video):
 
     cleaner = pd.read_csv('attendance-system.csv')
     cleaner.drop(cleaner.index, inplace=True)
     cleaner.to_csv('attendance-system.csv', index=False)
 
     # construct the argument parser and parse the arguments
     ap = argparse.ArgumentParser()
     ap.add_argument("-d", "--detector", default="face_detection_model",
                     help="path to OpenCV's deep learning face detector")
     ap.add_argument("-m", "--embedding-model", default="models/openface_nn4.small2.v1.t7",
                     help="path to OpenCV's deep learning face embedding model")
     ap.add_argument("-r", "--recognizer", default="models/5c_cnn_recognizer.pickle",
                     help="path to model trained to recognize faces")
     ap.add_argument("-l", "--le", default="models/5c_cnn_labelencoder.pickle",
                     help="path to label encoder")
     ap.add_argument("-c", "--confidence", type=float, default=0.5,
                     help="minimum probability to filter weak detections")
     args = vars(ap.parse_args())
 
     # load our serialized face detector from disk
     print("[INFO] loading face detector...")
     protoPath = os.path.sep.join([args["detector"], "deploy.prototxt"])
     modelPath = os.path.sep.join([args["detector"],
                                   "res10_300x300_ssd_iter_140000.caffemodel"])
     detector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)
 
     # load our serialized face embedding model from disk
     print("[INFO] loading face recognizer...")
     embedder = cv2.dnn.readNetFromTorch(args["embedding_model"])
 
     # load the actual face recognition model along with the label encoder
     recognizer = pickle.loads(open(args["recognizer"], "rb").read())
     le = pickle.loads(open(args["le"], "rb").read())
 
     # initialize the video stream, then allow the camera sensor to warm up
 
     # start the FPS throughput estimator
     fps = FPS().start()
     faces_list = []
     proba_list = []
     proba = 0
     count = 0
     now = datetime.now()
     dictionaryin = {}
     dictionaryout = {}
 
     unknown_counter = 0
 
     # loop over frames from the video file stream
     while True:
         # grab the frame from the threaded video stream
         success, image = video.read()
 
         frame = image
         # resize the frame to have a width of 600 pixels (while
         # maintaining the aspect ratio), and then grab the image
         # dimensions
         frame = imutils.resize(frame, width=600)
         (h, w) = frame.shape[:2]
 
         dt_string = now.strftime("%d/%m/%Y")
         hr_string = strftime("%H:%M:%S", localtime())
 
         # construct a blob from the image
         imageBlob = cv2.dnn.blobFromImage(
             cv2.resize(frame, (300, 300)), 1.0, (300, 300),
             (104.0, 177.0, 123.0), swapRB=False, crop=False)
 
         # apply OpenCV's deep learning-based face detector to localize
         # faces in the input image
         detector.setInput(imageBlob)
         detections = detector.forward()
 
         # loop over the detections
         for i in range(0, detections.shape[2]):
             # extract the confidence (i.e., probability) associated with
             # the prediction
             confidence = detections[0, 0, i, 2]
 
             # filter out weak detections
             if confidence > args["confidence"]:
                 # compute the (x, y)-coordinates of the bounding box for
                 # the face
                 box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
                 (startX, startY, endX, endY) = box.astype("int")
 
                 # extract the face ROI
                 face = frame[startY:endY, startX:endX]
                 (fH, fW) = face.shape[:2]
 
                 # ensure the face width and height are sufficiently large
                 if fW < 20 or fH < 20:
                     continue
 
                 # construct a blob for the face ROI, then pass the blob
                 # through our face embedding model to obtain the 128-d
                 # quantification of the face
                 faceBlob = cv2.dnn.blobFromImage(face, 1.0 / 255,
                                                  (96, 96), (0, 0, 0), swapRB=True, crop=False)
                 embedder.setInput(faceBlob)
                 vec = embedder.forward()
 
                 # perform classification to recognize the face
                 preds = recognizer.predict_proba(vec)
                 j = np.argmax(preds)
                 proba = preds[j]
                 name = le.classes_[j]
                 img_counter = 0
 
                 # draw the bounding box of the face along with the
                 # associated probability
                 text = "{}: {:.2f}%".format(name, proba * 100)
                 y = startY - 10 if startY - 10 > 10 else startY + 10
                 cv2.rectangle(frame, (startX, startY), (endX, endY),
                               (0, 0, 255), 2)
                 cv2.putText(frame, text, (startX, y),
                             cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)
 
                 # print(le.classes_)
 
                 if proba >= 0.70:
                     faces_list.append(name)
                     proba_list.append(proba)
                     count = count + 1
 
-                if name == "Mridulata":
+                if name == "name1":
                     if proba >= 0.80:
-                        cv2.putText(frame, "WELCOME MRIDULATA!!!", (40, 60),
+                        cv2.putText(frame, "WELCOME name1!!!", (40, 60),
                                     cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
 
-                if name == "Smrity":
+                if name == "name2":
                     if proba >= 0.80:
-                        cv2.putText(frame, "WELCOME SMRITY!!!", (40, 60),
+                        cv2.putText(frame, "WELCOME name2!!!", (40, 60),
                                     cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
 
-                if name == "saloni":
+                if name == "name3":
                     if proba >= 0.80:
-                        cv2.putText(frame, "WELCOME SALONI!!!", (40, 60),
+                        cv2.putText(frame, "WELCOME name3!!!", (40, 60),
                                     cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
 
-                if name == "Sujata":
+                if name == "name4":
                     if proba >= 0.80:
-                        cv2.putText(frame, "WELCOME SUJATA!!!", (40, 60),
+                        cv2.putText(frame, "WELCOME name4!!!", (40, 60),
                                     cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
 
                 if name == "unknown":
                     if proba >= 0.80:
                         unknown_dir = "images/unknown"
                         test = datetime
                         unknowns_name = unknown_dir + os.sep + "unknown" + ".jpg"
                         cv2.imwrite(unknowns_name, frame)
                         unknown_counter += 1
 
         if count == 20:
 
             d = defaultdict(list)
             for key, value in zip(faces_list, proba_list):
                 d[key].append(value)
             occurence = dict(d)
             thisset = set(occurence)
             for x in thisset:
                 occurance_individual = len(occurence[x])
                 occurence[x] = sum(item for item in occurence[x])
 
             a = sum(occurence.values())
 
             for x in thisset:
                 occurence[x] = occurence[x] / a
 
             attendance = {word for word, prob in occurence.items() if prob >= 0.3}
             # students = max(occurence, key=occurence.get)
             students = list(attendance)
 
             headers = ['Date', 'Name', 'Time Sign In', 'Time Sign Out']
 
             def write_csv(data):
 
                 with open('attendance-system.csv', 'a') as outfile:
                     outfile.truncate()
                     file_is_empty = os.stat('attendance-system.csv').st_size == 0
                     writer = csv.writer(outfile, lineterminator='\n', )
                     if file_is_empty:
                         writer.writerow(headers)
 
                     writer.writerow(data)
 
             # time.sleep(1)
             current_hour = datetime.now().second
             fps.stop()
             waktu = fps.elapsed()
 
             if waktu >= 0 and waktu <= 15:
                 print('Attendance system Open for sign in')
                 for a in students:
                     write_csv([dt_string, a, hr_string, ''])
 
                 records = pd.read_csv('attendance-system.csv')  # Records dictionaryin for notification
                 deduped = records.drop_duplicates(['Name'], keep='first')
                 deduped = deduped.drop(columns=['Time Sign Out'])
                 dictionaryin = deduped.set_index('Name').T.to_dict('list')
 
             elif waktu >= 30 and waktu <= 45:
 
                 for a in students:
                     write_csv([dt_string, a, '', hr_string])
                 print('Attendance system Open for sign out')
 
                 records = pd.read_csv('attendance-system.csv')  # Records dictionaryout for notification
                 signed_out = records.loc[records['Time Sign Out'].notna()]
                 deduped_out = signed_out.drop_duplicates(['Name'], keep='first')
                 deduped_out = deduped_out.drop(columns=['Time Sign In'])
                 dictionaryout = deduped_out.set_index('Name').T.to_dict('list')
             else:
                 print('Attendance system close until Next Course')
 
             print(dt_string, hr_string, students)
 
             faces_list.clear()
             proba_list.clear()
             count = 0
 
 
 
         # update the FPS counter
         fps.update()
 
         ret, jpeg = cv2.imencode('.jpg', frame)
         frame = jpeg.tobytes()
         yield (b'--frame\r\n'
                b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
 
         key = cv2.waitKey(1) & 0xFF
 
         # if the `q` key was pressed, break from the loop
         if key == ord("q"):
             break
 
 
 
 # stop the timer and display FPS information
         fps.stop()
 
         records = pd.read_csv('attendance-system.csv')
         deduped = records.drop_duplicates(['Name'], keep='first')
         deduped = deduped.drop(columns=['Time Sign Out'])
 
         signed_out = records.loc[records['Time Sign Out'].notna()]
         deduped_out = signed_out.drop_duplicates(['Name'], keep='first')
         deduped_out = deduped_out.drop(columns=['Time Sign In'])
 
         mergedStuff = pd.merge(deduped, deduped_out, on=['Name'], suffixes=(' Sign In', ' Sign Out'))
         attend_data = mergedStuff[mergedStuff.Name != 'unknown']
         attend_data.to_csv('attendance-data.csv', index=False)
 
         print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
         print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
 1
         # do a bit of cleanup
 
 cv2.destroyAllWindows()
 
 @app.route('/video_feed')
 def video_feed():
     global video
     return Response(gen(video),
                     mimetype='multipart/x-mixed-replace; boundary=frame')
 
 
 
 
 
 @app.route('/recognize', methods=['POST'])
 def detect():
     file = request.files['image']
 
     # Read image
     image = read_image(file)
 
     # Recognize faces
     classifier_model_path = "models" + os.sep + "4c_recognizer.pickle"
     label_encoder_path = "models" + os.sep + "4c_labelencoder.pickle"
     faces = recognize_faces(image, classifier_model_path, label_encoder_path,
                             detection_api_url=app.config["DETECTION_API_URL"])
 
     return jsonify(recognitions=faces)
 
 
 @app.route('/upload', methods=['POST'])
 def upload():
     file = request.files['image']
 
     # Read image
     image = read_image(file)
 
     # Recognize faces
     classifier_model_path = "models" + os.sep + "4c_recognizer.pickle"
     label_encoder_path = "models" + os.sep + "4c_labelencoder.pickle"
     faces = recognize_faces(image, classifier_model_path, label_encoder_path,
                             detection_api_url=app.config["DETECTION_API_URL"])
 
     # Draw detection rects
     draw_rectangles(image, faces)
 
     # Prepare image for html
     to_send = prepare_image(image)
 
     return render_template('stillphoto.html', face_recognized=len(faces) > 0, num_faces=len(faces), image_to_show=to_send,
                            init=True)
 
 
 
 @app.route('/static')
 def static_page():
     with app.app_context():
         return render_template('stillphoto.html')
 
 @app.route('/admin')
 def admin():
     with app.app_context():
         return render_template('admin.html')
 
 @app.route('/employee')
 def employee():
     with app.app_context():
         return render_template('employee.html')
 
 @app.route('/login')
 def login():
     return render_template('login.html')
 
 def gene(video):
     cleaner = pd.read_csv('attendance-system.csv')
     cleaner.drop(cleaner.index, inplace=True)
     cleaner.to_csv('attendance-system.csv', index=False)
 
     # construct the argument parser and parse the arguments
     ap = argparse.ArgumentParser()
     ap.add_argument("-d", "--detector", default="face_detection_model",
                     help="path to OpenCV's deep learning face detector")
     ap.add_argument("-m", "--embedding-model", default="models/openface_nn4.small2.v1.t7",
                     help="path to OpenCV's deep learning face embedding model")
     ap.add_argument("-r", "--recognizer", default="models/5c_cnn_recognizer.pickle",
                     help="path to model trained to recognize faces")
     ap.add_argument("-l", "--le", default="models/5c_cnn_labelencoder.pickle",
                     help="path to label encoder")
     ap.add_argument("-c", "--confidence", type=float, default=0.5,
                     help="minimum probability to filter weak detections")
     args = vars(ap.parse_args())
 
     # load our serialized face detector from disk
     print("[INFO] loading face detector...")
     protoPath = os.path.sep.join([args["detector"], "deploy.prototxt"])
     modelPath = os.path.sep.join([args["detector"],
                                   "res10_300x300_ssd_iter_140000.caffemodel"])
     detector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)
 
     # load our serialized face embedding model from disk
     print("[INFO] loading face recognizer...")
     embedder = cv2.dnn.readNetFromTorch(args["embedding_model"])
 
     # load the actual face recognition model along with the label encoder
     recognizer = pickle.loads(open(args["recognizer"], "rb").read())
     le = pickle.loads(open(args["le"], "rb").read())
 
     # initialize the video stream, then allow the camera sensor to warm up
 
     # start the FPS throughput estimator
     fps = FPS().start()
     faces_list = []
     proba_list = []
     proba = 0
     count = 0
     now = datetime.now()
     dictionaryin = {}
     dictionaryout = {}
 
     unknown_counter = 0
 
     # loop over frames from the video file stream
 
 
 
     while True:
         # grab the frame from the threaded video stream
         success, image = video.read()
 
         frame = image
         # resize the frame to have a width of 600 pixels (while
         # maintaining the aspect ratio), and then grab the image
         # dimensions
         frame = imutils.resize(frame, width=600)
         (h, w) = frame.shape[:2]
 
         dt_string = now.strftime("%d/%m/%Y")
         hr_string = strftime("%H:%M:%S", localtime())
 
         # construct a blob from the image
         imageBlob = cv2.dnn.blobFromImage(
             cv2.resize(frame, (300, 300)), 1.0, (300, 300),
             (104.0, 177.0, 123.0), swapRB=False, crop=False)
 
         # apply OpenCV's deep learning-based face detector to localize
         # faces in the input image
         detector.setInput(imageBlob)
         detections = detector.forward()
 
         # loop over the detections
         for i in range(0, detections.shape[2]):
             # extract the confidence (i.e., probability) associated with
             # the prediction
             confidence = detections[0, 0, i, 2]
 
             # filter out weak detections
             if confidence > args["confidence"]:
                 # compute the (x, y)-coordinates of the bounding box for
                 # the face
                 box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
                 (startX, startY, endX, endY) = box.astype("int")
 
                 # extract the face ROI
                 face = frame[startY:endY, startX:endX]
                 (fH, fW) = face.shape[:2]
 
                 # ensure the face width and height are sufficiently large
                 if fW < 20 or fH < 20:
                     continue
 
                 # construct a blob for the face ROI, then pass the blob
                 # through our face embedding model to obtain the 128-d
                 # quantification of the face
                 faceBlob = cv2.dnn.blobFromImage(face, 1.0 / 255,
                                                  (96, 96), (0, 0, 0), swapRB=True, crop=False)
                 embedder.setInput(faceBlob)
                 vec = embedder.forward()
 
                 # perform classification to recognize the face
                 preds = recognizer.predict_proba(vec)
                 j = np.argmax(preds)
                 proba = preds[j]
                 name = le.classes_[j]
                 img_counter = 0
 
                 # draw the bounding box of the face along with the
                 # associated probability
                 text = "{}: {:.2f}%".format(name, proba * 100)
                 y = startY - 10 if startY - 10 > 10 else startY + 10
                 cv2.rectangle(frame, (startX, startY), (endX, endY),
                               (0, 0, 255), 2)
                 cv2.putText(frame, text, (startX, y),
                             cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)
 
                 # print(le.classes_)
 
                 if proba >= 0.70:
                     faces_list.append(name)
                     proba_list.append(proba)
                     count = count + 1
 
-                if name == "Mridulata":
+                if name == "name1":
                     if proba >= 0.80:
-                        name = "Mridulata"
+                        name = "name1"
                         with app.app_context():
                             return  render_template('admin.html', value = name)
 
-                if name == "Smrity":
+                if name == "name2":
                     if proba >= 0.40:
-                        name = "Smrity"
+                        name = "name2"
                         with app.app_context():
                             return render_template('employee.html', value=name)
 
-                if name == "saloni":
+                if name == "name3":
                     if proba >= 0.40:
                         with app.app_context():
                             return render_template('employee.html', value=name)
 
-                if name == "Sujata":
+                if name == "name4":
                     if proba >= 0.40:
                         with app.app_context():
                             return render_template('employee.html', value=name)
 
                 if name == "unknown":
                     if proba >= 0.80:
                         unknown_dir = "images/unknown"
                         test = datetime
                         unknowns_name = unknown_dir + os.sep + "unknown" + ".jpg"
                         cv2.imwrite(unknowns_name, frame)
                         unknown_counter += 1
 
 
 
         if count == 20:
 
             d = defaultdict(list)
             for key, value in zip(faces_list, proba_list):
                 d[key].append(value)
             occurence = dict(d)
             thisset = set(occurence)
             for x in thisset:
                 occurance_individual = len(occurence[x])
                 occurence[x] = sum(item for item in occurence[x])
 
             a = sum(occurence.values())
 
             for x in thisset:
                 occurence[x] = occurence[x] / a
 
             attendance = {word for word, prob in occurence.items() if prob >= 0.3}
             # students = max(occurence, key=occurence.get)
             students = list(attendance)
 
             headers = ['Date', 'Name', 'Time Sign In', 'Time Sign Out']
 
             def write_csv(data):
 
                 with open('attendance-system.csv', 'a') as outfile:
                     outfile.truncate()
                     file_is_empty = os.stat('attendance-system.csv').st_size == 0
                     writer = csv.writer(outfile, lineterminator='\n', )
                     if file_is_empty:
                         writer.writerow(headers)
 
                     writer.writerow(data)
 
             # time.sleep(1)
             current_hour = datetime.now().second
             fps.stop()
             waktu = fps.elapsed()
 
             if waktu >= 0 and waktu <= 15:
                 print('Attendance system Open for sign in')
                 for a in students:
                     write_csv([dt_string, a, hr_string, ''])
 
                 records = pd.read_csv('attendance-system.csv')  # Records dictionaryin for notification
                 deduped = records.drop_duplicates(['Name'], keep='first')
                 deduped = deduped.drop(columns=['Time Sign Out'])
                 dictionaryin = deduped.set_index('Name').T.to_dict('list')
 
             elif waktu >= 30 and waktu <= 45:
 
                 for a in students:
                     write_csv([dt_string, a, '', hr_string])
                 print('Attendance system Open for sign out')
 
                 records = pd.read_csv('attendance-system.csv')  # Records dictionaryout for notification
                 signed_out = records.loc[records['Time Sign Out'].notna()]
                 deduped_out = signed_out.drop_duplicates(['Name'], keep='first')
                 deduped_out = deduped_out.drop(columns=['Time Sign In'])
                 dictionaryout = deduped_out.set_index('Name').T.to_dict('list')
             else:
                 print('Attendance system close until Next Course')
 
             print(dt_string, hr_string, students)
 
             faces_list.clear()
             proba_list.clear()
             count = 0
 
         # update the FPS counter
         fps.update()
 
         ret, jpeg = cv2.imencode('.jpg', frame)
         frame = jpeg.tobytes()
         yield (b'--frame\r\n'
                b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
 
         # stop the timer and display FPS information
 
         key = cv2.waitKey(1) & 0xFF
 
         # if the `q` key was pressed, break from the loop
         if key == ord("q"):
             break
 
         fps.stop()
 
         records = pd.read_csv('attendance-system.csv')
         deduped = records.drop_duplicates(['Name'], keep='first')
         deduped = deduped.drop(columns=['Time Sign Out'])
 
         signed_out = records.loc[records['Time Sign Out'].notna()]
         deduped_out = signed_out.drop_duplicates(['Name'], keep='first')
         deduped_out = deduped_out.drop(columns=['Time Sign In'])
 
         mergedStuff = pd.merge(deduped, deduped_out, on=['Name'], suffixes=(' Sign In', ' Sign Out'))
         attend_data = mergedStuff[mergedStuff.Name != 'unknown']
         attend_data.to_csv('attendance-data.csv', index=False)
 
         print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
         print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
 
         # do a bit of cleanup
 
 
 
 
 
 @app.route('/login_feed')
 def login_feed():
     global video
     return Response(gene(video),
                     mimetype='multipart/x-mixed-replace; boundary=frame')
 
 cv2.destroyAllWindows()
 
 
 @app.route('/profile/<username>')
 def profile(username):
     return "welcome to profile page %s" % username
 
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=5000, threaded=True)