Create app.py

app.py

@@ -0,0 +1,1203 @@
+from streamlit_webrtc import webrtc_streamer, RTCConfiguration
+import av
+import streamlit as st
+import mediapipe as mp
+import cv2
+import time
+import math
+import numpy as np
+# import pandas as pd
+# import tensorflow as tf
+import variables
+
+from download import download_file
+from turn import get_ice_servers
+
+# # face bounder indices
+# FACE_OVAL=[ 10, 338, 297, 332, 284, 251, 389, 356, 454, 323, 361, 288, 397, 365, 379, 378, 400, 377, 152, 148, 176, 149, 150, 136, 172, 58, 132, 93, 234, 127, 162, 21, 54, 103,67, 109]
+# variables
+frame_counter = 0
+CEF_COUNTER = 0
+TOTAL_BLINKS = 0
+# constants
+CLOSED_EYES_FRAME = 3
+FONTS = cv2.FONT_HERSHEY_COMPLEX
+
+# face bounder indices
+FACE_OVAL = [10, 338, 297, 332, 284, 251, 389, 356, 454, 323, 361, 288, 397, 365, 379, 378,
+             400, 377, 152, 148, 176, 149, 150, 136, 172, 58, 132, 93, 234, 127, 162, 21, 54, 103, 67, 109]
+
+# lips indices for Landmarks
+LIPS = [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 308, 324, 318, 402, 317, 14, 87, 178,
+        88, 95, 185, 40, 39, 37, 0, 267, 269, 270, 409, 415, 310, 311, 312, 13, 82, 81, 42, 183, 78]
+LOWER_LIPS = [61, 146, 91, 181, 84, 17, 314, 405, 321,
+              375, 291, 308, 324, 318, 402, 317, 14, 87, 178, 88, 95]
+UPPER_LIPS = [185, 40, 39, 37, 0, 267, 269, 270,
+              409, 415, 310, 311, 312, 13, 82, 81, 42, 183, 78]
+
+# Left eyes indices
+LEFT_EYE = [362, 382, 381, 380, 374, 373, 390,
+            249, 263, 466, 388, 387, 386, 385, 384, 398]
+LEFT_EYEBROW = [336, 296, 334, 293, 300, 276, 283, 282, 295, 285]
+
+# right eyes indices
+RIGHT_EYE = [33, 7, 163, 144, 145, 153, 154,
+             155, 133, 173, 157, 158, 159, 160, 161, 246]
+RIGHT_EYEBROW = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
+
+UPPER_EYE_LEFT = [246, 161, 160, 159, 158, 157, 173, 133]
+UPPER_EYE_RIGHT = [7, 33, 161, 160, 159, 158, 157, 173]
+
+counter = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+full_counter = 0
+
+
+def landmarksDetection(img, results, draw=False):
+    img_height, img_width = img.shape[:2]
+    # list[(x,y), (x,y)....]
+    mesh_coord = [(int(point.x * img_width), int(point.y * img_height))
+                  for point in results.face_landmarks.landmark]
+    if draw:
+        [cv2.circle(img, p, 2, (0, 0, 255), -1) for p in mesh_coord]
+
+    # returning the list of tuples for each landmarks
+    return mesh_coord
+
+# Euclaidean distance
+
+
+def euclaideanDistance(point, point1):
+    x, y = point
+    x1, y1 = point1
+    distance = math.sqrt((x1 - x)**2 + (y1 - y)**2)
+    return distance
+
+# Blinking Ratio
+
+
+def blinkRatio(img, landmarks, right_indices, left_indices):
+
+    rh_right = landmarks[right_indices[0]]
+    rh_left = landmarks[right_indices[8]]
+    # vertical line
+    rv_top = landmarks[right_indices[12]]
+    rv_bottom = landmarks[right_indices[4]]
+
+    lh_right = landmarks[left_indices[0]]
+    lh_left = landmarks[left_indices[8]]
+
+    # vertical line
+    lv_top = landmarks[left_indices[12]]
+    lv_bottom = landmarks[left_indices[4]]
+
+    rhDistance = euclaideanDistance(rh_right, rh_left)
+    rvDistance = euclaideanDistance(rv_top, rv_bottom)
+
+    lvDistance = euclaideanDistance(lv_top, lv_bottom)
+    lhDistance = euclaideanDistance(lh_right, lh_left)
+
+    reRatio = rhDistance/rvDistance
+    leRatio = lhDistance/lvDistance
+
+    ratio = (reRatio+leRatio)/2
+    return ratio
+
+# Eyes Extrctor function,
+
+
+def eyesExtractor(img, right_eye_coords, left_eye_coords):
+    # converting color image to  scale image
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+    # getting the dimension of image
+    dim = gray.shape
+
+    # creating mask from gray scale dim
+    mask = np.zeros(dim, dtype=np.uint8)
+
+    # drawing Eyes Shape on mask with white color
+    cv2.fillPoly(mask, [np.array(right_eye_coords, dtype=np.int32)], 255)
+    cv2.fillPoly(mask, [np.array(left_eye_coords, dtype=np.int32)], 255)
+
+    # showing the mask
+    # cv.imshow('mask', mask)
+
+    # draw eyes image on mask, where white shape is
+    eyes = cv2.bitwise_and(gray, gray, mask=mask)
+    # change black color to gray other than eys
+    # cv.imshow('eyes draw', eyes)
+    eyes[mask == 0] = 155
+
+    # getting minium and maximum x and y  for right and left eyes
+    # For Right Eye
+    r_max_x = (max(right_eye_coords, key=lambda item: item[0]))[0]
+    r_min_x = (min(right_eye_coords, key=lambda item: item[0]))[0]
+    r_max_y = (max(right_eye_coords, key=lambda item: item[1]))[1]
+    r_min_y = (min(right_eye_coords, key=lambda item: item[1]))[1]
+
+    # For LEFT Eye
+    l_max_x = (max(left_eye_coords, key=lambda item: item[0]))[0]
+    l_min_x = (min(left_eye_coords, key=lambda item: item[0]))[0]
+    l_max_y = (max(left_eye_coords, key=lambda item: item[1]))[1]
+    l_min_y = (min(left_eye_coords, key=lambda item: item[1]))[1]
+
+    # croping the eyes from mask
+    cropped_right = eyes[r_min_y: r_max_y, r_min_x: r_max_x]
+    cropped_left = eyes[l_min_y: l_max_y, l_min_x: l_max_x]
+
+    # returning the cropped eyes
+    return cropped_right, cropped_left
+
+# Eyes Postion Estimator
+
+
+def positionEstimator(cropped_eye):
+    # getting height and width of eye
+    h, w = cropped_eye.shape
+
+    # remove the noise from images
+    gaussain_blur = cv2.GaussianBlur(cropped_eye, (9, 9), 0)
+    median_blur = cv2.medianBlur(gaussain_blur, 3)
+
+    # applying thrsholding to convert binary_image
+    ret, threshed_eye = cv2.threshold(median_blur, 130, 255, cv2.THRESH_BINARY)
+
+    # create fixd part for eye with
+    piece = int(w/3)
+
+    # slicing the eyes into three parts
+    right_piece = threshed_eye[0:h, 0:piece]
+    center_piece = threshed_eye[0:h, piece: piece+piece]
+    left_piece = threshed_eye[0:h, piece + piece:w]
+
+    # calling pixel counter function
+    eye_position = pixelCounter(right_piece, center_piece, left_piece)
+
+    return eye_position
+
+# creating pixel counter function
+
+
+def pixelCounter(first_piece, second_piece, third_piece):
+    # counting black pixel in each part
+    right_part = np.sum(first_piece == 0)
+    center_part = np.sum(second_piece == 0)
+    left_part = np.sum(third_piece == 0)
+    # creating list of these values
+    eye_parts = [right_part, center_part, left_part]
+
+    # getting the index of max values in the list
+    max_index = eye_parts.index(max(eye_parts))
+    pos_eye = ''
+    if max_index == 0:
+        pos_eye = "RIGHT"
+    elif max_index == 1:
+        pos_eye = 'CENTER'
+    elif max_index == 2:
+        pos_eye = 'LEFT'
+    else:
+        pos_eye = "Closed"
+    return pos_eye
+
+# Function to check if eyes are looking up
+
+# Load your TFLite model
+# interpreter = tf.lite.Interpreter(model_path='model_second.tflite')
+# interpreter.allocate_tensors()
+
+# # Get input and output details
+# input_details = interpreter.get_input_details()
+# output_details = interpreter.get_output_details()
+
+# # Assuming your input tensor name is 'flatten_input'
+# input_tensor_index = input_details[0]['index']
+# output_tensor_index = output_details[0]['index']
+
+# # You can use the following function for inference
+# def predict_label(input_data):
+#     # Set the input tensor
+#     interpreter.set_tensor(input_tensor_index, input_data)
+
+#     # Run inference
+#     interpreter.invoke()
+
+#     # Get the output tensor
+#     output_data = interpreter.get_tensor(output_tensor_index)
+
+#     # Convert the output to class labels
+#     predicted_label = np.argmax(output_data, axis=1)
+
+#     # Decode the predicted label
+#     # predicted_class = label_encoder.classes_[predicted_label][0]
+
+#     return predicted_label
+
+# class Queue:
+#     def __init__(self, max_size=80):
+#         self.max_size = max_size
+#         self.queue = []
+
+#     def enqueue(self, value):
+#         if len(self.queue) < self.max_size:
+#             self.queue.append(value)
+#         else:
+#             self.queue.pop(0)
+#             self.queue.append(value)
+
+#     def dequeue(self):
+#         if self.queue:
+#             self.queue.pop(0)
+#         else:
+#             print("Queue is empty. Dequeue operation failed.")
+
+#     def get_all_values(self):
+#         return self.queue
+    
+# frames_list = Queue(max_size=80)
+
+def is_eyes_looking_up(landmarks, upper_eye_indices):
+    upper_eye_points = [landmarks[idx] for idx in upper_eye_indices]
+    average_y = sum(point[1]
+                    for point in upper_eye_points) / len(upper_eye_points)
+    return average_y < landmarks[LEFT_EYE[0]][1] and average_y < landmarks[RIGHT_EYE[0]][1]
+
+def gen_report():
+    global nerv_bool
+    global pos_val
+    global report_generated
+    global report_data
+    global nerv_val
+    report_generated = True
+    # print("Arsooo")
+    # print("Session: ", st.session_state.pos_val)
+    if(nerv_bool):
+        pos_val += f"Person was Nervous and Blinked {nerv_val} times in 1 Minute"
+    report_data = pos_val
+
+report_generated = False
+nerv_bool = False
+nerv_val = 0
+pos_val = ""
+
+our_time = 0
+
+start_time = time.time()
+
+nervous = False
+
+mp_drawing = mp.solutions.drawing_utils  # Drawing helpers
+mp_holistic = mp.solutions.holistic  # Mediapipe Solutions
+
+holistic = mp_holistic.Holistic(
+    min_detection_confidence=0.5, min_tracking_confidence=0.5)
+
+class VideoProcessor:
+    def __init__(self):
+        self.reporter = False
+
+    def recv(self, frame: av.VideoFrame) -> av.VideoFrame:
+        global full_counter
+        global TOTAL_BLINKS
+        global CEF_COUNTER
+        global CLOSED_EYES_FRAME
+        global our_time
+        global start_time
+        global nervous
+        global nerv_bool
+        global pos_val
+        global report_generated
+        global report_data
+        global nerv_val
+        # global frames_list
+
+        frame = frame.to_ndarray(format="bgr24")
+
+        full_counter += 1
+
+        # Recolor Feed
+        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        image.flags.writeable = False
+
+        # Make Detections
+        results = holistic.process(image)
+
+        # Recolor image back to BGR for rendering
+        image.flags.writeable = True
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+        img_h, img_w, img_c = image.shape
+        face_3d = []
+        face_2d = []
+
+        # 1. Draw face landmarks
+        mp_drawing.draw_landmarks(image, results.face_landmarks, mp_holistic.FACEMESH_CONTOURS,
+                                  mp_drawing.DrawingSpec(
+                                      color=(80, 110, 10), thickness=1, circle_radius=1),
+                                  mp_drawing.DrawingSpec(
+                                      color=(80, 256, 121), thickness=1, circle_radius=1)
+                                  )
+
+        # 2. Right hand
+        mp_drawing.draw_landmarks(image, results.right_hand_landmarks, mp_holistic.HAND_CONNECTIONS,
+                                  mp_drawing.DrawingSpec(
+                                      color=(80, 22, 10), thickness=2, circle_radius=4),
+                                  mp_drawing.DrawingSpec(
+                                      color=(80, 44, 121), thickness=2, circle_radius=2)
+                                  )
+
+        # 3. Left Hand
+        mp_drawing.draw_landmarks(image, results.left_hand_landmarks, mp_holistic.HAND_CONNECTIONS,
+                                  mp_drawing.DrawingSpec(
+                                      color=(121, 22, 76), thickness=2, circle_radius=4),
+                                  mp_drawing.DrawingSpec(
+                                      color=(121, 44, 250), thickness=2, circle_radius=2)
+                                  )
+
+        # 4. Pose Detections
+        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_holistic.POSE_CONNECTIONS,
+                                  mp_drawing.DrawingSpec(
+                                      color=(245, 117, 66), thickness=2, circle_radius=4),
+                                  mp_drawing.DrawingSpec(
+                                      color=(245, 66, 230), thickness=2, circle_radius=2)
+                                  )
+
+        if (results.right_hand_landmarks and results.left_hand_landmarks and results.face_landmarks and results.pose_landmarks):
+            right_hand_landmarks = results.right_hand_landmarks.landmark
+            left_hand_landmarks = results.left_hand_landmarks.landmark
+            pose_landmarks = results.pose_landmarks.landmark
+            face_landmarks = results.face_landmarks.landmark
+
+            mesh_coords = landmarksDetection(frame, results, False)
+
+            bottom_lip = face_landmarks[18]
+            nose_center = face_landmarks[5]
+
+            right_wrist = pose_landmarks[16]
+
+            lips_left = face_landmarks[287]
+            lips_right = face_landmarks[57]
+
+            right_ear_top = face_landmarks[21]
+            right_ear_bottom = face_landmarks[215]
+
+            left_ear_top = face_landmarks[389]
+            left_ear_bottom = face_landmarks[361]
+
+            forehead = face_landmarks[151]
+
+            bottom_lip_y = int(bottom_lip.y * frame.shape[0])
+            upper_nose_y = int(nose_center.y * frame.shape[0])
+
+            lips_left_x = int(lips_left.x * frame.shape[1])
+            lips_right_x = int(lips_right.x * frame.shape[1])
+            lips_left_y = int(lips_left.y * frame.shape[0])
+            lips_right_y = int(lips_right.y * frame.shape[0])
+
+            right_ear_top_y = int(right_ear_top.y * frame.shape[0])
+            right_ear_top_x = int(right_ear_top.x * frame.shape[1])
+            right_ear_bottom_x = int(right_ear_bottom.x * frame.shape[1])
+            right_ear_bottom_y = int(right_ear_bottom.y * frame.shape[0])
+
+            left_ear_top_y = int(left_ear_top.y * frame.shape[0])
+            left_ear_top_x = int(left_ear_top.x * frame.shape[1])
+            left_ear_bottom_y = int(left_ear_bottom.y * frame.shape[0])
+            left_ear_bottom_x = int(left_ear_bottom.x * frame.shape[1])
+
+            right_hand_tip_x = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP].x * frame.shape[1])
+            left_hand_tip_x = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP].x * frame.shape[1])
+            right_hand_tip_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP].y * frame.shape[0])
+            left_hand_tip_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP].y * frame.shape[0])
+            right_hand_dip_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_DIP].y * frame.shape[0])
+            left_hand_dip_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_DIP].y * frame.shape[0])
+            right_hand_thumb = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.THUMB_TIP].y * frame.shape[0])
+            left_hand_thumb = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.THUMB_TIP].y * frame.shape[0])
+            right_shoulder = pose_landmarks[12]
+            left_shoulder = pose_landmarks[11]
+            mouth_left = pose_landmarks[9]
+            mouth_right = pose_landmarks[10]
+
+            right_hand_middle_finger_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.MIDDLE_FINGER_TIP].y * frame.shape[0])
+            right_hand_middle_finger_x = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.MIDDLE_FINGER_TIP].x * frame.shape[1])
+            right_hand_ring_finger_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.RING_FINGER_TIP].y * frame.shape[0])
+            right_hand_ring_finger_x = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.RING_FINGER_TIP].x * frame.shape[1])
+            right_hand_pinky_finger_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.PINKY_TIP].y * frame.shape[0])
+            right_hand_pinky_finger_x = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.PINKY_TIP].x * frame.shape[1])
+
+            left_hand_middle_finger_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.MIDDLE_FINGER_TIP].y * frame.shape[0])
+            left_hand_middle_finger_x = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.MIDDLE_FINGER_TIP].x * frame.shape[1])
+            left_hand_ring_finger_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.RING_FINGER_TIP].y * frame.shape[0])
+            left_hand_ring_finger_x = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.RING_FINGER_TIP].x * frame.shape[1])
+            left_hand_pinky_finger_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.PINKY_TIP].y * frame.shape[0])
+            left_hand_pinky_finger_x = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.PINKY_TIP].x * frame.shape[1])
+
+            forehead_y = int(forehead.y * frame.shape[0])
+
+            right_hand_middle_finger_dip_y = int(
+                right_hand_landmarks[11].y * frame.shape[0])
+            right_hand_ring_finger_dip_y = int(
+                right_hand_landmarks[15].y * frame.shape[0])
+            right_hand_pinky_dip_y = int(
+                right_hand_landmarks[19].y * frame.shape[0])
+
+            left_hand_middle_finger_dip_y = int(
+                right_hand_landmarks[11].y * frame.shape[0])
+            left_hand_ring_finger_dip_y = int(
+                right_hand_landmarks[15].y * frame.shape[0])
+            left_hand_pinky_dip_y = int(
+                left_hand_landmarks[19].y * frame.shape[0])
+
+            right_index_middle_finger_distance = right_hand_middle_finger_x - right_hand_tip_x
+            right_middle_ring_finger_distance = right_hand_ring_finger_x - \
+                right_hand_middle_finger_x
+
+            left_index_middle_finger_distance = left_hand_middle_finger_x - left_hand_tip_x
+            right_middle_ring_finger_distance = right_hand_ring_finger_x - \
+                right_hand_middle_finger_x
+
+            # eye_pupil_right_x = int(face_landmarks[468].x * frame.shape[1])
+            # eye_pupil_left_x = int(face_landmarks[473].x * frame.shape[1])
+
+            ring_finger_distance = right_hand_ring_finger_y - left_hand_ring_finger_y
+
+            mouth_left_y = int(mouth_left.y * frame.shape[0])
+            mouth_right_y = int(mouth_right.y * frame.shape[0])
+            right_shoulder_y = int(right_shoulder.y * frame.shape[0])
+            left_shoulder_y = int(left_shoulder.y * frame.shape[0])
+
+            val_hand_tips = left_hand_tip_x - right_hand_tip_x
+            val_hand_thumbs = left_hand_thumb - right_hand_thumb
+
+            lips_left = face_landmarks[287]
+            lips_right = face_landmarks[57]
+
+            lips_left_x = int(lips_left.x * frame.shape[1])
+            lips_right_x = int(lips_right.x * frame.shape[1])
+
+            face_landmarks = results.face_landmarks.landmark
+
+            thumb_tip = right_hand_landmarks[mp_holistic.HandLandmark.THUMB_TIP]
+            index_finger_tip = right_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP]
+            right_cheek = face_landmarks[116]
+            right_ear = face_landmarks[147]
+            chin = face_landmarks[152]
+            left_cheek = face_landmarks[323]
+
+            thumb_tip_y = int(thumb_tip.y * frame.shape[0])
+            thumb_tip_x = int(thumb_tip.x * frame.shape[1])
+            index_finger_tip_y = int(index_finger_tip.y * frame.shape[0])
+            index_finger_tip_x = int(index_finger_tip.x * frame.shape[1])
+            cheek_y = int(right_cheek.y * frame.shape[0])
+            right_ear_x = int(right_ear.x * frame.shape[1])
+            chin_y = int(chin.y * frame.shape[0])
+            left_cheek_x = int(left_cheek.x * frame.shape[1])
+
+            lips_left_y_distance = lips_left_y - lips_right_y
+            lips_right_y_distance = lips_right_y - lips_left_y
+
+            index_finger_distance_x = left_hand_tip_x - right_hand_tip_x
+            if ((right_hand_tip_y < right_hand_middle_finger_y) and (right_hand_tip_y < right_hand_ring_finger_y) and (right_hand_tip_y < right_hand_pinky_finger_y) and (right_hand_tip_y < thumb_tip_y)):
+                if ((right_hand_tip_y > upper_nose_y) and (right_hand_tip_y < bottom_lip_y) and (right_hand_tip_x > lips_left_x) and (right_hand_tip_x < lips_right_x)):
+                    cv2.putText(image, "Disagree with Spoken Word", (50, 50),
+                                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                    counter[0] += 1
+            elif ((right_hand_tip_y > right_hand_dip_y) and (right_hand_middle_finger_y > right_hand_middle_finger_dip_y) and (right_hand_ring_finger_y > right_hand_ring_finger_dip_y) and (right_hand_pinky_finger_y > right_hand_pinky_dip_y) and (left_hand_tip_y > left_hand_dip_y) and (left_hand_middle_finger_y > left_hand_middle_finger_dip_y) and (left_hand_ring_finger_y > left_hand_ring_finger_dip_y) and (left_hand_pinky_finger_y > left_hand_pinky_dip_y) and (right_hand_tip_x > (right_ear_top_x-40)) and (right_hand_tip_x < right_ear_top_x) and (left_hand_tip_x < (left_ear_top_x+40)) and (left_hand_tip_x > left_ear_top_x) and (lips_left_y > lips_right_y or lips_right_y > lips_left_y) and ((lips_left_y_distance > 1 and lips_left_y_distance < 40) or (lips_right_y_distance > 1 and lips_right_y_distance < 40))):
+                cv2.putText(image, "Annoyed", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[2] += 1
+            elif ((right_hand_tip_y < right_shoulder_y and left_hand_tip_y < left_shoulder_y) and (right_hand_tip_y > mouth_right_y) and (left_hand_tip_y > mouth_left_y) and (right_hand_dip_y > right_hand_tip_y and left_hand_dip_y > left_hand_tip_y) and (left_hand_tip_x < lips_left_x) and (right_hand_tip_x > lips_right_x) and (val_hand_tips < 20 and val_hand_thumbs < 20)):
+                cv2.putText(image, "Wants her knowledge to be recognized now",
+                            (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[8] += 1
+            elif (((right_hand_tip_y < right_hand_dip_y) and (right_hand_middle_finger_y < right_hand_middle_finger_dip_y) and (right_hand_ring_finger_y < right_hand_ring_finger_dip_y) and (right_hand_tip_y < right_hand_dip_y)) and ((left_hand_tip_y < left_hand_dip_y) and (left_hand_middle_finger_y < left_hand_middle_finger_dip_y) and (left_hand_ring_finger_y < left_hand_ring_finger_dip_y) and (left_hand_pinky_finger_y < left_hand_pinky_dip_y)) and (is_eyes_looking_up(mesh_coords, UPPER_EYE_LEFT + UPPER_EYE_RIGHT)) and (right_hand_tip_y < chin_y and right_hand_tip_y > forehead_y) and (left_hand_tip_y < chin_y and left_hand_tip_y > forehead_y) and (right_hand_tip_x > right_ear_top_x and left_hand_tip_x < left_ear_top_x) and (index_finger_distance_x > 20)):
+                cv2.putText(image, "Reobserve, Feeling Uncomfortable", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[1] += 1
+            else:
+                cv2.putText(image, "Neutral", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[7] += 1
+
+        elif results.face_landmarks and results.right_hand_landmarks and results.pose_landmarks:
+            face_landmarks = results.face_landmarks.landmark
+            right_hand_landmarks = results.right_hand_landmarks.landmark
+            pose_landmarks = results.pose_landmarks.landmark
+
+            for idx, lm in enumerate(face_landmarks):
+                if idx == 33 or idx == 263 or idx == 1 or idx == 61 or idx == 291 or idx == 199:
+                    if idx == 1:
+                        nose_2d = (lm.x * img_w, lm.y * img_h)
+                        nose_3d = (lm.x * img_w, lm.y * img_h, lm.z * 3000)
+
+                    x, y = int(lm.x * img_w), int(lm.y * img_h)
+
+                    # Get the 2D Coordinates
+                    face_2d.append([x, y])
+
+                    # Get the 3D Coordinates
+                    face_3d.append([x, y, lm.z])
+
+            # Convert it to the NumPy array
+            face_2d = np.array(face_2d, dtype=np.float64)
+
+            # Convert it to the NumPy array
+            face_3d = np.array(face_3d, dtype=np.float64)
+
+            # The camera matrix
+            focal_length = 1 * img_w
+
+            cam_matrix = np.array([[focal_length, 0, img_h / 2],
+                                   [0, focal_length, img_w / 2],
+                                   [0, 0, 1]])
+
+            # The distortion parameters
+            dist_matrix = np.zeros((4, 1), dtype=np.float64)
+
+            # Solve PnP
+            success, rot_vec, trans_vec = cv2.solvePnP(
+                face_3d, face_2d, cam_matrix, dist_matrix)
+
+            # Get rotational matrix
+            rmat, jac = cv2.Rodrigues(rot_vec)
+
+            # Get angles
+            angles, mtxR, mtxQ, Qx, Qy, Qz = cv2.RQDecomp3x3(rmat)
+
+            # Get the y rotation degree
+            x = angles[0] * 360
+            y = angles[1] * 360
+            z = angles[2] * 360
+
+            head_text = ""
+
+            # See where the user's head tilting
+            if y < -10:
+                head_text = "Looking Left"
+            elif y > 10:
+                head_text = "Looking Right"
+            elif x < -10:
+                head_text = "Looking Down"
+            elif x > 10:
+                head_text = "Looking Up"
+            else:
+                head_text = "Forward"
+
+            # Display the nose direction
+            nose_3d_projection, jacobian = cv2.projectPoints(
+                nose_3d, rot_vec, trans_vec, cam_matrix, dist_matrix)
+
+            p1 = (int(nose_2d[0]), int(nose_2d[1]))
+            p2 = (int(nose_2d[0] + y * 10), int(nose_2d[1] - x * 10))
+
+            # cv2.line(image, p1, p2, (255, 0, 0), 3)
+
+            # Add the text on the image
+            # cv2.putText(image, head_text, (20, 50), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2)
+            # cv2.putText(image, "x: " + str(np.round(x,2)), (500, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            # cv2.putText(image, "y: " + str(np.round(y,2)), (500, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            # cv2.putText(image, "z: " + str(np.round(z,2)), (500, 150), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+
+            mesh_coords = landmarksDetection(frame, results, False)
+
+            thumb_tip = right_hand_landmarks[mp_holistic.HandLandmark.THUMB_TIP]
+            index_finger_tip = right_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP]
+            right_cheek = face_landmarks[116]
+            right_ear = face_landmarks[147]
+            chin = face_landmarks[152]
+            left_cheek = face_landmarks[323]
+
+            thumb_tip_y = int(thumb_tip.y * frame.shape[0])
+            thumb_tip_x = int(thumb_tip.x * frame.shape[1])
+            index_finger_tip_y = int(index_finger_tip.y * frame.shape[0])
+            index_finger_tip_x = int(index_finger_tip.x * frame.shape[1])
+            cheek_y = int(right_cheek.y * frame.shape[0])
+            right_ear_x = int(right_ear.x * frame.shape[1])
+            chin_y = int(chin.y * frame.shape[0])
+            left_cheek_x = int(left_cheek.x * frame.shape[1])
+
+            right_wrist = pose_landmarks[16]
+
+            right_wrist_y = int(right_wrist.y * frame.shape[0])
+
+            head_top = face_landmarks[10]
+            head_below = face_landmarks[152]
+
+            nose_top = face_landmarks[197]
+            nose_bottom = face_landmarks[4]
+            nose_left = face_landmarks[49]
+            nose_right = face_landmarks[279]
+
+            nose_top_y = int(nose_top.y * frame.shape[0])
+            nose_bottom_y = int(nose_bottom.y * frame.shape[0])
+            nose_left_x = int(nose_left.x * frame.shape[1])
+            nose_right_x = int(nose_right.x * frame.shape[1])
+
+            head_top_y = int(head_top.y * frame.shape[0])
+            head_below_y = int(head_below.y * frame.shape[0])
+
+            mouth_lip_upper = face_landmarks[13]
+            mouth_lip_lower = face_landmarks[14]
+
+            bottom_lip = face_landmarks[18]
+            nose_center = face_landmarks[1]
+
+            right_ear_top = face_landmarks[21]
+            right_ear_bottom = face_landmarks[215]
+
+            lips_left = face_landmarks[287]
+            lips_right = face_landmarks[57]
+
+            bottom_lip_y = int(bottom_lip.y * frame.shape[0])
+            upper_nose_y = int(nose_center.y * frame.shape[0])
+
+            lips_left_x = int(lips_left.x * frame.shape[1])
+            lips_right_x = int(lips_right.x * frame.shape[1])
+
+            left_cheek = face_landmarks[323]
+
+            right_ear_top_y = int(right_ear_top.y * frame.shape[0])
+            right_ear_top_x = int(right_ear_top.x * frame.shape[1])
+            right_ear_bottom_x = int(right_ear_bottom.x * frame.shape[1])
+            right_ear_bottom_y = int(right_ear_bottom.y * frame.shape[0])
+
+            mouth_lip_upper_y = int(mouth_lip_upper.y * frame.shape[0])
+            mouth_lip_lower_y = int(mouth_lip_lower.y * frame.shape[0])
+
+            right_hand_tip_x = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP].x * frame.shape[1])
+            right_hand_tip_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP].y * frame.shape[0])
+
+            thumb_tip = right_hand_landmarks[mp_holistic.HandLandmark.THUMB_TIP]
+
+            head_top_x = int(head_top.x * frame.shape[1])
+            right_wrist_x = int(right_wrist.x * frame.shape[1])
+
+            thumb_tip_y = int(thumb_tip.y * frame.shape[0])
+            thumb_tip_x = int(thumb_tip.x * frame.shape[1])
+            chin = face_landmarks[152]
+            chin_y = int(chin.y * frame.shape[0])
+
+            lips_distance = mouth_lip_lower_y - mouth_lip_upper_y
+
+            right_ear_hand_distance = head_top_x - right_wrist_x
+
+            right_hand_middle_finger_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.MIDDLE_FINGER_TIP].y * frame.shape[0])
+            right_hand_middle_finger_x = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.MIDDLE_FINGER_TIP].x * frame.shape[1])
+            right_hand_ring_finger_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.RING_FINGER_TIP].y * frame.shape[0])
+            right_hand_ring_finger_x = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.RING_FINGER_TIP].x * frame.shape[1])
+            right_hand_pinky_finger_y = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.PINKY_TIP].y * frame.shape[0])
+            right_hand_pinky_finger_x = int(
+                right_hand_landmarks[mp_holistic.HandLandmark.PINKY_TIP].x * frame.shape[1])
+
+            left_cheek_x = int(left_cheek.x * frame.shape[1])
+
+            if ((right_hand_tip_y < right_hand_middle_finger_y) and (right_hand_tip_y < right_hand_ring_finger_y) and (right_hand_tip_y < right_hand_pinky_finger_y) and (right_hand_tip_y < thumb_tip_y) and (right_hand_tip_y > upper_nose_y) and (right_hand_tip_y < bottom_lip_y) and (right_hand_tip_x < lips_left_x) and (right_hand_tip_x > lips_right_x)):
+                cv2.putText(image, "Disagree with Spoken Word", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[0] += 1
+            elif ((right_hand_tip_y > right_ear_top_y) and (right_hand_tip_y < right_ear_bottom_y) and (right_hand_tip_x > (right_ear_top_x-40)) and (right_hand_tip_x < right_ear_top_x)):
+                cv2.putText(image, "Disagree what was heard", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[3] += 1
+            elif (lips_distance > 10):
+                cv2.putText(image, "Disbelief", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[4] += 1
+            elif ((right_hand_tip_y < nose_bottom_y) and (right_hand_tip_y > nose_top_y) and (right_hand_tip_x > nose_left_x) and (right_hand_tip_x < nose_right_x)):
+                cv2.putText(image, "Untruthful", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[5] += 1
+            elif ((right_wrist_y > head_top_y) and (right_wrist_y < head_below_y) and (right_ear_hand_distance < 100) and (head_text == "Looking Down")):
+                cv2.putText(image, "Embarrased, Got Caught", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[6] += 1
+            elif ((chin_y > thumb_tip_y) and (right_ear_x < thumb_tip_x) and (thumb_tip_y > cheek_y) and (thumb_tip_x < left_cheek_x) and (head_text == "Looking Up")) or ((chin_y > index_finger_tip_y) and (right_ear_x < index_finger_tip_x) and (index_finger_tip_y > cheek_y) and (index_finger_tip_x < left_cheek_x) and (head_text == "Looking Up")):
+                cv2.putText(image, "Positive evaluation low risk situation", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[9] += 1
+            else:
+                cv2.putText(image, "Neutral", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[7] += 1
+
+        elif results.face_landmarks and results.left_hand_landmarks and results.pose_landmarks:
+            face_landmarks = results.face_landmarks.landmark
+            left_hand_landmarks = results.left_hand_landmarks.landmark
+            pose_landmarks = results.pose_landmarks.landmark
+
+            for idx, lm in enumerate(face_landmarks):
+                if idx == 33 or idx == 263 or idx == 1 or idx == 61 or idx == 291 or idx == 199:
+                    if idx == 1:
+                        nose_2d = (lm.x * img_w, lm.y * img_h)
+                        nose_3d = (lm.x * img_w, lm.y * img_h, lm.z * 3000)
+
+                    x, y = int(lm.x * img_w), int(lm.y * img_h)
+
+                    # Get the 2D Coordinates
+                    face_2d.append([x, y])
+
+                    # Get the 3D Coordinates
+                    face_3d.append([x, y, lm.z])
+
+            # Convert it to the NumPy array
+            face_2d = np.array(face_2d, dtype=np.float64)
+
+            # Convert it to the NumPy array
+            face_3d = np.array(face_3d, dtype=np.float64)
+
+            # The camera matrix
+            focal_length = 1 * img_w
+
+            cam_matrix = np.array([[focal_length, 0, img_h / 2],
+                                   [0, focal_length, img_w / 2],
+                                   [0, 0, 1]])
+
+            # The distortion parameters
+            dist_matrix = np.zeros((4, 1), dtype=np.float64)
+
+            # Solve PnP
+            success, rot_vec, trans_vec = cv2.solvePnP(
+                face_3d, face_2d, cam_matrix, dist_matrix)
+
+            # Get rotational matrix
+            rmat, jac = cv2.Rodrigues(rot_vec)
+
+            # Get angles
+            angles, mtxR, mtxQ, Qx, Qy, Qz = cv2.RQDecomp3x3(rmat)
+
+            # Get the y rotation degree
+            x = angles[0] * 360
+            y = angles[1] * 360
+            z = angles[2] * 360
+
+            head_text = ""
+
+            # See where the user's head tilting
+            if y < -10:
+                head_text = "Looking Left"
+            elif y > 10:
+                head_text = "Looking Right"
+            elif x < -10:
+                head_text = "Looking Down"
+            elif x > 10:
+                head_text = "Looking Up"
+            else:
+                head_text = "Forward"
+
+            # Display the nose direction
+            nose_3d_projection, jacobian = cv2.projectPoints(
+                nose_3d, rot_vec, trans_vec, cam_matrix, dist_matrix)
+
+            p1 = (int(nose_2d[0]), int(nose_2d[1]))
+            p2 = (int(nose_2d[0] + y * 10), int(nose_2d[1] - x * 10))
+
+            # cv2.line(image, p1, p2, (255, 0, 0), 3)
+
+            # Add the text on the image
+            # cv2.putText(image, head_text, (20, 50), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2)
+            # cv2.putText(image, "x: " + str(np.round(x,2)), (500, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            # cv2.putText(image, "y: " + str(np.round(y,2)), (500, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            # cv2.putText(image, "z: " + str(np.round(z,2)), (500, 150), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+
+            mesh_coords = landmarksDetection(frame, results, False)
+
+            thumb_tip = left_hand_landmarks[mp_holistic.HandLandmark.THUMB_TIP]
+            index_finger_tip = left_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP]
+            left_cheek = face_landmarks[345]
+            left_ear = face_landmarks[376]
+            chin = face_landmarks[152]
+            left_cheek = face_landmarks[352]
+
+            thumb_tip_y = int(thumb_tip.y * frame.shape[0])
+            thumb_tip_x = int(thumb_tip.x * frame.shape[1])
+            index_finger_tip_y = int(index_finger_tip.y * frame.shape[0])
+            index_finger_tip_x = int(index_finger_tip.x * frame.shape[1])
+            cheek_y = int(left_cheek.y * frame.shape[0])
+            left_ear_x = int(left_ear.x * frame.shape[1])
+            chin_y = int(chin.y * frame.shape[0])
+            left_cheek_x = int(left_cheek.x * frame.shape[1])
+
+            left_wrist = pose_landmarks[15]
+
+            left_wrist_y = int(left_wrist.y * frame.shape[0])
+
+            head_top = face_landmarks[10]
+            head_below = face_landmarks[152]
+
+            nose_top = face_landmarks[197]
+            nose_bottom = face_landmarks[4]
+            nose_left = face_landmarks[49]
+            nose_right = face_landmarks[279]
+
+            nose_top_y = int(nose_top.y * frame.shape[0])
+            nose_bottom_y = int(nose_bottom.y * frame.shape[0])
+            nose_left_x = int(nose_left.x * frame.shape[1])
+            nose_right_x = int(nose_right.x * frame.shape[1])
+
+            head_top_y = int(head_top.y * frame.shape[0])
+            head_below_y = int(head_below.y * frame.shape[0])
+
+            mouth_lip_upper = face_landmarks[13]
+            mouth_lip_lower = face_landmarks[14]
+
+            bottom_lip = face_landmarks[18]
+            nose_center = face_landmarks[1]
+
+            left_ear_top = face_landmarks[251]
+            left_ear_bottom = face_landmarks[435]
+
+            lips_left = face_landmarks[287]
+            lips_right = face_landmarks[57]
+
+            bottom_lip_y = int(bottom_lip.y * frame.shape[0])
+            upper_nose_y = int(nose_center.y * frame.shape[0])
+
+            lips_left_x = int(lips_left.x * frame.shape[1])
+            lips_right_x = int(lips_right.x * frame.shape[1])
+
+            left_cheek = face_landmarks[323]
+
+            left_ear_top_y = int(left_ear_top.y * frame.shape[0])
+            left_ear_top_x = int(left_ear_top.x * frame.shape[1])
+            left_ear_bottom_x = int(left_ear_bottom.x * frame.shape[1])
+            left_ear_bottom_y = int(left_ear_bottom.y * frame.shape[0])
+
+            mouth_lip_upper_y = int(mouth_lip_upper.y * frame.shape[0])
+            mouth_lip_lower_y = int(mouth_lip_lower.y * frame.shape[0])
+
+            left_hand_tip_x = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP].x * frame.shape[1])
+            left_hand_tip_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.INDEX_FINGER_TIP].y * frame.shape[0])
+
+            thumb_tip = left_hand_landmarks[mp_holistic.HandLandmark.THUMB_TIP]
+
+            head_top_x = int(head_top.x * frame.shape[1])
+            left_wrist_x = int(left_wrist.x * frame.shape[1])
+
+            thumb_tip_y = int(thumb_tip.y * frame.shape[0])
+            thumb_tip_x = int(thumb_tip.x * frame.shape[1])
+            chin = face_landmarks[152]
+            chin_y = int(chin.y * frame.shape[0])
+
+            lips_distance = mouth_lip_lower_y - mouth_lip_upper_y
+
+            left_ear_hand_distance = left_wrist_x - head_top_x
+
+            left_hand_middle_finger_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.MIDDLE_FINGER_TIP].y * frame.shape[0])
+            left_hand_middle_finger_x = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.MIDDLE_FINGER_TIP].x * frame.shape[1])
+            left_hand_ring_finger_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.RING_FINGER_TIP].y * frame.shape[0])
+            left_hand_ring_finger_x = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.RING_FINGER_TIP].x * frame.shape[1])
+            left_hand_pinky_finger_y = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.PINKY_TIP].y * frame.shape[0])
+            left_hand_pinky_finger_x = int(
+                left_hand_landmarks[mp_holistic.HandLandmark.PINKY_TIP].x * frame.shape[1])
+
+            left_cheek_x = int(left_cheek.x * frame.shape[1])
+
+            if ((left_hand_tip_y < left_hand_middle_finger_y) and (left_hand_tip_y < left_hand_ring_finger_y) and (left_hand_tip_y < left_hand_pinky_finger_y) and (left_hand_tip_y < thumb_tip_y) and (left_hand_tip_y > upper_nose_y) and (left_hand_tip_y < bottom_lip_y) and (left_hand_tip_x < lips_left_x) and (left_hand_tip_x > lips_right_x)):
+                cv2.putText(image, "Disagree with Spoken Word", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[0] += 1
+            elif ((left_hand_tip_y > left_ear_top_y) and (left_hand_tip_y < left_ear_bottom_y) and (left_hand_tip_x < (left_ear_top_x+40)) and (left_hand_tip_x > left_ear_top_x)):
+                cv2.putText(image, "Disagree what was heard", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[3] += 1
+            elif (lips_distance > 10):
+                cv2.putText(image, "Disbelief", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[4] += 1
+            elif ((left_hand_tip_y < nose_bottom_y) and (left_hand_tip_y > nose_top_y) and (left_hand_tip_x > nose_left_x) and (left_hand_tip_x < nose_right_x)):
+                cv2.putText(image, "Untruthful", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[5] += 1
+            elif ((left_wrist_y > head_top_y) and (left_wrist_y < head_below_y) and (left_ear_hand_distance < 100) and (head_text == "Looking Down")):
+                cv2.putText(image, "Embarrased, Got Caught", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[6] += 1
+            elif ((chin_y > thumb_tip_y) and (left_ear_x > thumb_tip_x) and (thumb_tip_y > cheek_y) and (thumb_tip_x > left_cheek_x) and (head_text == "Looking Up")) or ((chin_y > index_finger_tip_y) and (left_ear_x > index_finger_tip_x) and (index_finger_tip_y > cheek_y) and (index_finger_tip_x > left_cheek_x) and (head_text == "Looking Up")):
+                cv2.putText(image, "Positive evaluation low risk situation", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[9] += 1
+            else:
+                cv2.putText(image, "Neutral", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[7] += 1
+
+        elif results.pose_landmarks and results.face_landmarks:
+            face_landmarks = results.face_landmarks.landmark
+            pose_landmarks = results.pose_landmarks.landmark
+
+            for idx, lm in enumerate(face_landmarks):
+                if idx == 33 or idx == 263 or idx == 1 or idx == 61 or idx == 291 or idx == 199:
+                    if idx == 1:
+                        nose_2d = (lm.x * img_w, lm.y * img_h)
+                        nose_3d = (lm.x * img_w, lm.y * img_h, lm.z * 3000)
+
+                    x, y = int(lm.x * img_w), int(lm.y * img_h)
+
+                    # Get the 2D Coordinates
+                    face_2d.append([x, y])
+
+                    # Get the 3D Coordinates
+                    face_3d.append([x, y, lm.z])
+
+            # Convert it to the NumPy array
+            face_2d = np.array(face_2d, dtype=np.float64)
+
+            # Convert it to the NumPy array
+            face_3d = np.array(face_3d, dtype=np.float64)
+
+            # The camera matrix
+            focal_length = 1 * img_w
+
+            cam_matrix = np.array([[focal_length, 0, img_h / 2],
+                                   [0, focal_length, img_w / 2],
+                                   [0, 0, 1]])
+
+            # The distortion parameters
+            dist_matrix = np.zeros((4, 1), dtype=np.float64)
+
+            # Solve PnP
+            success, rot_vec, trans_vec = cv2.solvePnP(
+                face_3d, face_2d, cam_matrix, dist_matrix)
+
+            # Get rotational matrix
+            rmat, jac = cv2.Rodrigues(rot_vec)
+
+            # Get angles
+            angles, mtxR, mtxQ, Qx, Qy, Qz = cv2.RQDecomp3x3(rmat)
+
+            # Get the y rotation degree
+            x = angles[0] * 360
+            y = angles[1] * 360
+            z = angles[2] * 360
+
+            head_text = ""
+
+            # See where the user's head tilting
+            if y < -10:
+                head_text = "Looking Left"
+            elif y > 10:
+                head_text = "Looking Right"
+            elif x < -10:
+                head_text = "Looking Down"
+            elif x > 10:
+                head_text = "Looking Up"
+            else:
+                head_text = "Forward"
+
+            # Display the nose direction
+            nose_3d_projection, jacobian = cv2.projectPoints(
+                nose_3d, rot_vec, trans_vec, cam_matrix, dist_matrix)
+
+            p1 = (int(nose_2d[0]), int(nose_2d[1]))
+            p2 = (int(nose_2d[0] + y * 10), int(nose_2d[1] - x * 10))
+
+            mesh_coords = landmarksDetection(frame, results, False)
+
+            right_wrist = pose_landmarks[16]
+
+            right_wrist_x = int(right_wrist.x * frame.shape[1])
+            right_wrist_y = int(right_wrist.y * frame.shape[0])
+
+            head_top = face_landmarks[10]
+            head_below = face_landmarks[152]
+
+            head_top_y = int(head_top.y * frame.shape[0])
+            head_below_y = int(head_below.y * frame.shape[0])
+
+            head_top_x = int(head_top.x * frame.shape[1])
+
+            right_ear_hand_distance = head_top_x - right_wrist_x
+
+            ratio = blinkRatio(frame, mesh_coords, RIGHT_EYE, LEFT_EYE)
+            # cv.putText(frame, f'ratio {ratio}', (100, 100), FONTS, 1.0, utils.GREEN, 2)
+
+            if ratio > 5.5:
+                CEF_COUNTER += 1
+                # cv.putText(frame, 'Blink', (200, 50), FONTS, 1.3, utils.PINK, 2)
+                pass
+            else:
+                if CEF_COUNTER > CLOSED_EYES_FRAME:
+                    TOTAL_BLINKS += 1
+                    CEF_COUNTER = 0
+            # # cv.putText(frame, f'Total Blinks: {TOTAL_BLINKS}', (100, 150), FONTS, 0.6, utils.GREEN, 2)
+            # Blink Detector Counter Completed
+            right_coords = [mesh_coords[p] for p in RIGHT_EYE]
+            left_coords = [mesh_coords[p] for p in LEFT_EYE]
+            crop_right, crop_left = eyesExtractor(
+                frame, right_coords, left_coords)
+
+            eye_position = positionEstimator(crop_right)
+            eye_position_left = positionEstimator(crop_left)
+
+            mouth_lip_upper = face_landmarks[13]
+            mouth_lip_lower = face_landmarks[14]
+
+            right_eye_brow = face_landmarks[105]
+            left_eye_brow = face_landmarks[334]
+
+            right_eye_brow_upper = int(right_eye_brow.y * frame.shape[0])
+            left_eye_brow_upper = int(left_eye_brow.y * frame.shape[0])
+
+            distance_y_eye_brows = right_eye_brow_upper - left_eye_brow_upper
+            # print(distance_y_eye_brows)
+
+            mouth_lip_upper_y = int(mouth_lip_upper.y * frame.shape[0])
+            mouth_lip_lower_y = int(mouth_lip_lower.y * frame.shape[0])
+
+            lips_distance = mouth_lip_lower_y - mouth_lip_upper_y
+
+            frames_list.enqueue(x)
+            frames_list.enqueue(y)
+
+            if ((right_wrist_y > head_top_y) and (right_wrist_y < head_below_y) and (right_ear_hand_distance < 100) and (head_text == "Looking Down")):
+                cv2.putText(image, "Embarrased, Got Caught", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[6] += 1
+            elif (lips_distance > 10):
+                cv2.putText(image, "Disbelief", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[4] += 1
+            elif (head_text == "Looking Up" and ((eye_position == "LEFT" and eye_position_left == "LEFT") or (eye_position == "RIGHT" and eye_position_left == "RIGHT"))):
+                cv2.putText(image, "Person Recalling Something", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[17] += 1
+            elif((left_eye_brow_upper < right_eye_brow_upper) and (distance_y_eye_brows > 4 and distance_y_eye_brows < 10)):
+                cv2.putText(image, "Anger, Dislike, Skeptical", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[18] += 1
+            elif (ratio > 5.5):
+                cv2.putText(image, "Doesn't want to see, eye block", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[11] += 1
+            elif (((eye_position == "Closed" and eye_position_left == "CENTER") or (eye_position_left == "Closed" and eye_position == "CENTER")) and lips_distance > 50):
+                cv2.putText(image, "Approval", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[16] += 1
+            elif((eye_position == "RIGHT" and eye_position_left == "RIGHT") or (eye_position == "LEFT" and eye_position_left == "LEFT")):
+                cv2.putText(image, "Hostility, skeptical", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[19] += 1
+            else:
+                cv2.putText(image, "Disagree with Spoken Word", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                counter[7] += 1
+                # if(len(frames_list.get_all_values()) == 80):
+                #     input_data = np.array(frames_list.get_all_values())
+                #     input_data = input_data.reshape((40, 2))
+                #     predicted_class = predict_label(np.expand_dims(input_data, axis=0).astype(np.float32))
+                #     if(predicted_class[0] == 3):
+                #         cv2.putText(image, "Head Shake Slow", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                #         counter[12] += 1
+                #     elif(predicted_class[0] == 2):
+                #         cv2.putText(image, "Head Shake Fast", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                #         counter[13] += 1
+                #     elif(predicted_class[0] == 1):
+                #         cv2.putText(image, "Head Nod Slow", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                #         counter[14] += 1
+                #     elif(predicted_class[0] == 0):
+                #         cv2.putText(image, "Head Nod Fast", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+                #         counter[15] += 1
+                #     else:
+                #         cv2.putText(image, "Neutral", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)
+                #         counter[7] += 1
+                # else:
+                #     cv2.putText(image, "Neutral", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)
+                #     counter[7] += 1
+        del results
+        end_time = time.time()
+        timer_count = end_time - start_time
+        if((int(timer_count/60) > our_time and not nervous) or (int(timer_count) <= 60 and TOTAL_BLINKS >= 15)):
+            our_time = int(timer_count/60)
+            print("Sunny")
+            if(TOTAL_BLINKS >= 15):
+                print("Arsooo")
+                nervous = True
+                variables.nerv_val = TOTAL_BLINKS
+                variables.nerv_bool = True
+
+        pos_val = f"""
+        Disagree with Spoken Word: {(counter[0]/full_counter * 100)}%\n
+        Wants Her Knowledge to be Recognized Now: {(counter[8]/full_counter * 100)}%\n
+        Reobserve feeling Uncomfortable: {(counter[1]/full_counter * 100)}%\n
+        Positive Evaluation Low Risk Situation: {(counter[9]/full_counter * 100)}%\n
+        Annoyed: {(counter[2]/full_counter * 100)}%\n
+        Disagree what was heard: {(counter[3]/full_counter * 100)}%\n
+        Disbelief: {(counter[4]/full_counter * 100)}%\n
+        Untruthful: {(counter[5]/full_counter * 100)}%\n
+        Embarrased Got Caught: {(counter[6]/full_counter * 100)}%\n
+        Doesn't want to see, Eye Block: {(counter[11]/full_counter * 100)}%\n
+        Person Recalling Something: {(counter[17]/full_counter * 100)}%\n
+        Approval: {(counter[16]/full_counter * 100)}%\n
+        Anger, Dislike, Skeptical: {(counter[18]/full_counter * 100)}%\n
+        Hostility, Skeptical: {(counter[19]/full_counter * 100)}%\n
+        Neutral: {(counter[7]/full_counter * 100)}%\n
+        """
+        self.reporter = True
+        variables.my_variable += 10
+        variables.my_report = pos_val
+
+        return av.VideoFrame.from_ndarray(image, format='bgr24')
+
+ctx = webrtc_streamer(key="key",
+                video_processor_factory=VideoProcessor,
+                rtc_configuration={
+                    "iceServers": get_ice_servers(),
+                    "iceTransportPolicy": "relay",
+                },
+                media_stream_constraints={"video": True, "audio": False},
+                # async_processing=True
+                )
+
+if(ctx.video_transformer):
+    variables.my_variable = 10
+    variables.my_report = ""
+    variables.nerv_bool = False
+    variables.nerv_val = 0
+elif(not ctx.video_transformer and variables.my_variable > 10):
+    # print(variables.my_report)
+    if(variables.nerv_bool):
+        variables.my_report += f"Person was Nervous and Blinked {variables.nerv_val} times in 1 Minute"
+    st.write(variables.my_report)
+    variables.my_variable = 10
+    variables.my_report = ""
+    variables.nerv_bool = False
+    variables.nerv_val = 0
+    # del frames_list
+else:
+    variables.my_variable = 10
+    variables.my_report = ""
+    variables.nerv_bool = False
+    variables.nerv_val = 0
+    st.write(variables.my_report)
+    # del frames_list