def get_all_landmarks(self, frame):
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rects = self.detector(gray, 0)
landmarks = []
for rect in rects:
shape = self.predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
landmarks.append(shape)
return landmarks
def main():
camera = PiCamera()
camera.resolution = (1024, 768)
camera.start_preview()
# Camera warm-up time
sleep(1)
camera.capture('foo.jpg', resize=(1024, 768))
camera.stop_preview()
camera.close()
start = time.time()
img = cv.imread('foo.jpg')
w = len(img[0])
h = len(img)
M = cv.getRotationMatrix2D((w/2, h/2), 270, 1.0)
img = cv.warpAffine(img, M, (h, w))
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('/home/pi/Desktop/shape_predictor_68_face_landmarks.dat')
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
rects = detector(gray, 0)
if (len(rects) == 0):
return "Eyes: Failed Detection. Try Repositioning the Camera"
print(rects)
for rect in rects:
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
clone = img.copy()
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
for (x, y) in leftEye:
cv.circle(clone, (x, y), 1, (0, 0, 255), -1)
for (x, y) in rightEye:
cv.circle(clone, (x, y), 1, (0, 0, 255), -1)
leftEAR = ear_fn(leftEye)
rightEAR = ear_fn(rightEye)
ear = (leftEAR + rightEAR) / 2.0
if (ear < EAR):
return ("Closed")
eyeOpenClose = "Eyes: Closed"
else:
return ("Open")
eyeOpenClose = "Eyes: Open"
cv.putText(clone, eyeOpenClose, (100, 200), cv.FONT_ITALIC,
0.7, (0, 0, 255), 2)
end = time.time()
cv.imshow("Image", clone)
cv.waitKey(0)
print(end - start)
return
def detect_parts(image, filename):
distances = []
# resize the image, and convert it to grayscale
image = imutils.resize(image, width=200, height=200)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale image
rects = detector(gray, 1)
# loop over the face detections
for (i, rect) in enumerate(rects):
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
distances = euclidean_all(shape)
# output = face_utils.visualize_facial_landmarks(image, shape)
# visualize all facial landmarks with a transparent overlay
# cv2.imshow("Image", output)
# cv2.waitKey(0)
return distances
def main():
# return
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("Unable to connect to camera.")
return
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(face_landmark_path)
while cap.isOpened():
ret, frame = cap.read()
if ret:
face_rects = detector(frame, 0)
if len(face_rects) > 0:
shape = predictor(frame, face_rects[0])
shape = face_utils.shape_to_np(shape)
reprojectdst, euler_angle = get_head_pose(shape)
for (x, y) in shape:
cv2.circle(frame, (x, y), 1, (0, 0, 255), -1)
for start, end in line_pairs:
cv2.line(frame, reprojectdst[start], reprojectdst[end], (0, 0, 255))
cv2.putText(frame, "X: " + "{:7.2f}".format(euler_angle[0, 0]), (20, 20), cv2.FONT_HERSHEY_SIMPLEX,
0.75, (0, 0, 0), thickness=2)
cv2.putText(frame, "Y: " + "{:7.2f}".format(euler_angle[1, 0]), (20, 50), cv2.FONT_HERSHEY_SIMPLEX,
0.75, (0, 0, 0), thickness=2)
cv2.putText(frame, "Z: " + "{:7.2f}".format(euler_angle[2, 0]), (20, 80), cv2.FONT_HERSHEY_SIMPLEX,
0.75, (0, 0, 0), thickness=2)
cv2.imshow("demo", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
def calculate_distance(reference_clip, compare_clip):
# construct the `argument parse and parse the arguments
# ap = argparse.ArgumentParser()
# ap.add_argument("-p", "--shape-predictor", required=True, default = "shape_predictor_68_face_landmarks.dat",
# help="path to facial landmark predictor")
# ap.add_argument("-r", "--picamera", type=int, default=-1,
# help="whether or not the Raspberry Pi camera should be used")
# args = vars(ap.parse_args())
# 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()
# face 안에 얼굴 인식하는 기능
predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
# predictor = dlib.shape_predictor(args["shape_predictor"])
# vs = VideoStream(usePiCamera=args["picamera"] > 0).start()
# 비디오 출력 : https://076923.github.io/posts/Python-opencv-4/
# https://docs.opencv.org/master/dd/d43/tutorial_py_video_display.html
# capture = cv2.VideoCapture("cut_2.mp4")
clips = [reference_clip, compare_clip]
time.sleep(2.0)
clips_frame_info = []
for clip in clips:
i = 0
every_frame_info = []
# 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
# ret, frame = capture.read() # frame = numpy array임
frame = clip.get_frame(i * 1.0 / clip.fps)
i += skip_frame_rate # 1초에 60 fps가 있으므로 몇개는 skip해도 될거 같음!
if (i * 1.0 / clip.fps) > clip.duration:
break
# if not ret:
# print("Error")
# break
# width 높이면 더 판별 잘되지만, computational power 높음
# The benefit of increasing the resolution of the input image prior to face detection is that it may allow us to detect more faces in the imag
frame = imutils.resize(frame, width=800)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
# 얼굴 자체의 위치를 찾음
rects = detector(gray, 0)
if len(rects) > 0:
# 얼굴 개수만큼 loop
max_width = 0
max_rect = None
# 얼굴 박스 제일 큰거 하나로
for rect in rects:
if int(rects[0].width()) > max_width:
max_rect = rect
# determine the facial landmarks for the face region, then
# convert the facial landmark (x, y)-coordinates to a NumPy array
shape = predictor(gray, max_rect)
shape = face_utils.shape_to_np(shape)
every_frame_info.append(shape)
else:
every_frame_info.append([])
clips_frame_info.append(np.array(every_frame_info))
cv2.destroyAllWindows()
min_size = min(len(clips_frame_info[0]), len(clips_frame_info[1]))
min_diff = float("inf")
min_idx = 0
for i in range(min_size):
if len(clips_frame_info[0][i]) > 0 and len(
clips_frame_info[1][i]) > 0: # 얼굴 둘다 있으면
# 양쪽 눈
left_eye = ((clips_frame_info[0][i][36][0] -
clips_frame_info[1][i][36][0])**2 +
(clips_frame_info[0][i][36][1] -
clips_frame_info[1][i][36][1])**2)**0.5
right_eye = ((clips_frame_info[0][i][45][0] -
clips_frame_info[1][i][45][0])**2 +
(clips_frame_info[0][i][45][1] -
clips_frame_info[1][i][45][1])**2)**0.5
total_diff = left_eye + right_eye
if min_diff > total_diff:
min_diff = total_diff
min_idx = i
return min_diff, (min_idx *
skip_frame_rate) / clip.fps # 거리와 해당 초 위치를 계산해준다!
frame_check = 20
detect = dlib.get_frontal_face_detector()
predict = dlib.shape_predictor("C:\Users\akshaybahadur21\Documents\GitHub\Drowsiness_Detection|\shape_predictor_68_face_landmarks.dat")# Dat file is the crux of the code
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
cap=cv2.VideoCapture(0)
flag=0
while True:
ret, frame=cap.read()
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
subjects = detect(gray, 0)
for subject in subjects:
shape = predict(gray, subject)
shape = face_utils.shape_to_np(shape)#converting to NumPy Array
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
ear = (leftEAR + rightEAR) / 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)
if ear < thresh:
flag += 1
print (flag)
if flag >= frame_check:
cv2.putText(frame, "****************ALERT!****************", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
def detect_landmarks(face, frame, scale_x=0, scale_y=0):
(x, y, w, h) = (int(e) for e in face)
rectangle = dlib.rectangle(x, y, x + w, y + h)
face_landmarks = landmarks_detector(frame, rectangle)
return face_utils.shape_to_np(face_landmarks)
def blinkCounter(video):
directions = []
TOTAL = 0
COUNTER = 0
Total_Frames = 0
time_for_blink = []
consecutive_frames = []
print("starting blink detection on: ", video)
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(data_set)
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
vs = FileVideoStream(video).start()
fileStream = True
time.sleep(1.0)
while in_loop:
if fileStream and not vs.more():
return TOTAL, Total_Frames, time_for_blink, directions
frame = vs.read()
Total_Frames += 1
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 0)
for rect in rects:
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
ear = (leftEAR + rightEAR) / 2.0
if ear < EYE_AR_THRESH:
COUNTER += 1
consecutive_frames.append(Total_Frames)
else:
if COUNTER >= EYE_AR_CONSEC_FRAMES:
TOTAL += 1
if len(consecutive_frames) != 0:
timeStamp = consecutive_frames[0] / 30
time_for_blink.append(int(timeStamp))
consecutive_frames = []
COUNTER = 0
cv2.putText(frame, "Blinks: {}".format(TOTAL), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
return TOTAL, Total_Frames, time_for_blink, directions
if key == ord("7"):
print("Upper Left")
save_position("UL", Total_Frames, directions)
if key == ord("8"):
print("Up")
save_position("U", Total_Frames, directions)
if key == ord("9"):
print("Upper Right")
save_position("UR", Total_Frames, directions)
if key == ord("4"):
print("left")
save_position("L", Total_Frames, directions)
if key == ord("5"):
print("middle")
save_position("M", Total_Frames, directions)
if key == ord("6"):
print("right")
save_position("R", Total_Frames, directions)
if key == ord("1"):
print("down left")
save_position("DL", Total_Frames, directions)
if key == ord("2"):
print("down")
save_position("D", Total_Frames, directions)
if key == ord("3"):
print("down right")
save_position("DR", Total_Frames, directions)
cv2.destroyAllWindows()
vs.stop()
def auto_capturing(auto_path, man_path, mar_threshold, ear_threshold,
frame_waiter, verbose):
"""
Creates a cv2 window which opens a web camera and depending on conditions (eyes are open and smile)
take a snapshot, also available manual shots.
:param auto_path: str : Directory name where automatically captured photos will be stored
:param man_path: str : Directory name where manual captured photos will be stored
:param mar_threshold: (float, flaot) : Mouth Aspect Ratio threshold, (min, max):
to control smiling threshold, default numbers are computed
from trial and error, and may differ on
different mouth shapes. min controls smiling
without teeth, max controls smiling with teeth
:param ear_threshold: float : Eye Aspect Ratio threshold, if EAR is great or
great or equal this number, it means eyes are open,
and ready to a shot
:param frame_waiter: float : Number of frames that camera should wait before taking a snapshot
:param verbose: bool: Show contours around facial features and MAR and EAR values
:return: None
"""
COUNTER = 0 # frame counter
TOTAL = 0 # picture counter to update filename after each shot
try:
video_stream = VideoStream(src=0).start()
time.sleep(1.0)
cv2.namedWindow("auto-capture")
while True:
frame = video_stream.read()
frame = imutils.resize(frame, width=840)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 0)
for rect in rects:
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
# get mouth
mouth = shape[mouth_start:mouth_end]
MAR = smile(mouth)
# get eyes
left_eye = shape[left_eye_start:left_eye_end]
right_eye = shape[right_eye_start:right_eye_end]
left_EAR = blink(left_eye)
right_EAR = blink(right_eye)
EAR = (left_EAR + right_EAR) / 2
# check if eyes are opened and month is smiling
if (MAR <= mar_threshold[0]
or MAR > mar_threshold[1]) and (EAR >= ear_threshold):
COUNTER += 1
else:
# wait several frames
# this is done to detect if user smiles in a few milliseconds or it was just momentary
if COUNTER >= frame_waiter:
TOTAL += 1
frame = video_stream.read(
) # load the frame where user is ready (smiling)
# time.sleep(.05)
img_name = f"auto_capture_frame_{TOTAL}.png"
cv2.imwrite(auto_path + "/" + img_name, frame)
print(f"{img_name} written!") # console output
COUNTER = 0
if verbose:
# connect facial landmark points to make a contour around a landmark
mouth_hull = cv2.convexHull(mouth)
left_eye_hull = cv2.convexHull(left_eye)
right_eye_hull = cv2.convexHull(right_eye)
cv2.drawContours(frame, [mouth_hull], -1, (0, 255, 0), 1)
cv2.drawContours(frame, [left_eye_hull], -1,
(214, 16, 232), 1)
cv2.drawContours(frame, [right_eye_hull], -1,
(214, 16, 232), 1)
cv2.putText(frame, f"MAR: {MAR:.4f}", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
cv2.putText(frame, f"LEFT EAR: {left_EAR:.2f}", (10, 60),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (214, 16, 232),
2)
cv2.putText(frame, f"RIGHT EAR: {right_EAR:.2f}", (10, 90),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (214, 16, 232),
2)
cv2.imshow("Frame", frame)
key_pressed = cv2.waitKey(1) & 0xFF
if key_pressed == ord('q') or key_pressed == 27:
break
elif key_pressed == 13 or key_pressed == 32:
"""
When esc or q pressed take a manual shot, and continue the loop
"""
frame = video_stream.read()
time.sleep(.004)
img_name = f"manual_capture_{TOTAL}.png"
cv2.imwrite(man_path + "/" + img_name, frame)
print(f"{img_name} written!")
TOTAL += 1
continue
cv2.destroyAllWindows()
video_stream.stop()
except:
print("Make sure you have a Web Cam and it's connected to device")
def create_resource(ti=15,
v="Hybernation",
inac=5,
asleep=2,
fold="/home/satya/Pictures"):
# Initialize Pygame and load music
ft = 0
pygame.mixer.init()
pygame.mixer.music.load(r'assets\audio\faded.ogg')
# Minimum threshold of eye aspect ratio below which alarm is triggerd
EYE_ASPECT_RATIO_THRESHOLD = 0.3
# Minimum consecutive frames for which eye ratio is below threshold for alarm to be triggered
EYE_ASPECT_RATIO_CONSEC_FRAMES = 50
# COunts no. of consecutuve frames below threshold value
COUNTER = 0
b = 1
flag1 = True
global inace
# Load face cascade which will be used to draw a rectangle around detected faces.
face_cascade = cv2.CascadeClassifier(
r"assets\haarcascades\haarcascade_frontalface_default.xml")
# This function calculates and return eye aspect ratio
def eye_aspect_ratio(eye):
A = distance.euclidean(eye[1], eye[5])
B = distance.euclidean(eye[2], eye[4])
C = distance.euclidean(eye[0], eye[3])
# EAR = eye_aspect_ratio
ear = (A + B) / (2 * C)
return ear
# Load face detector and predictor, uses dlib shape predictor file
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(
r'assets\shape_predictor_68_face_landmarks.dat')
# Extract indexes of facial landmarks for the left and right eye
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS['left_eye']
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS['right_eye']
# Start webcam video capture /Give some time for camera to initialize(not required) /time.sleep(2)
a = 1
while (True):
video_capture = cv2.VideoCapture(0)
nowt = datetime.datetime.now()
nt1 = nowt.minute
newt = nowt + datetime.timedelta(minutes=ti)
nt2 = newt.minute
print("***********")
print(nowt, newt)
print("***********")
while (True):
# Read each frame and flip it, and convert to grayscale
ret, frame = video_capture.read()
frame = cv2.flip(frame, 1)
if ret:
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Detect facial points through detector function
faces = detector(gray, 0)
# Detect faces through haarcascade_frontalface_default.xml
face_rectangle = face_cascade.detectMultiScale(gray, 1.3, 5)
# Draw rectangle around each face detected
for (x, y, w, h) in face_rectangle:
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0),
2)
# Detect facial points
# print(type(faces))
if len(faces) == 0:
COUNTER = 0
inacs = datetime.datetime.now()
# print(inacs)
if flag1:
inace = inacs + datetime.timedelta(minutes=inac)
inace = inace.minute
flag1 = False
if (inacs.minute > inace and b == 1 and flag1 == False):
pygame.mixer.music.play(-1)
b = 0
print(inacs, inace)
if (b == 0 and flag1 == False and inacs.minute >
(inace + 1)):
flag1 = True
b = 1
pygame.mixer.music.stop()
pic = pyautogui.screenshot()
sour = fold + "screenshot.png"
pic.save(sour)
ft = 1
for face in faces:
if (b != 1):
flag1 = True
b = 1
pygame.mixer.music.stop()
shape = predictor(gray, face)
shape = face_utils.shape_to_np(shape)
# Get array of coordinates of leftEye and rightEye
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
# Calculate aspect ratio of both eyes
leftEyeAspectRatio = eye_aspect_ratio(leftEye)
rightEyeAspectRatio = eye_aspect_ratio(rightEye)
eyeAspectRatio = (leftEyeAspectRatio +
rightEyeAspectRatio) / 2
# Use hull to remove convex contour discrepencies and draw eye shape around eyes
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)
# Detect if eye aspect ratio is less than threshold
# print(eyeAspectRatio)
if (eyeAspectRatio < EYE_ASPECT_RATIO_THRESHOLD):
COUNTER += 1
# If no. of frames is greater than threshold frames,
print(COUNTER, EYE_ASPECT_RATIO_CONSEC_FRAMES)
if COUNTER >= EYE_ASPECT_RATIO_CONSEC_FRAMES and COUNTER >= asleep and a == 1:
pygame.mixer.music.play(-1)
a = 0
cv2.putText(frame, "You are Drowsy", (150, 200),
cv2.FONT_HERSHEY_SIMPLEX, 1.5,
(0, 0, 255), 2)
if COUNTER >= EYE_ASPECT_RATIO_CONSEC_FRAMES and COUNTER >= (
asleep + 20):
pic = pyautogui.screenshot()
sour = fold + "screenshot.png"
pic.save(sour)
pygame.mixer.music.stop()
ft = 1
break
else:
pygame.mixer.music.stop()
a = 1
COUNTER = 0
if ft == 1:
break
cv2.imshow('Video', frame)
kp = cv2.waitKey(1)
nt1 = datetime.datetime.now().minute
if (nt2 < nt1):
break
elif (kp & 0xFF == ord('q')):
return
if ft == 1:
video_capture.release()
cv2.destroyAllWindows()
pygame.mixer.music.stop()
break
else:
video_capture.release()
cv2.destroyAllWindows()
pygame.mixer.music.stop()
time.sleep(60 * ti)
if ft == 1:
time.sleep(10)
if v == "Hybernation":
changeStatus.hybernation()
else:
changeStatus.shut_down()
def gitsearch():
# This part contains the main code.
video_capture = cv2.VideoCapture(
0
) #starts the web cam if you attach it externally use 1 or 2 , use trail and error
detector = dlib.get_frontal_face_detector()
predict_path = '/home/shaaran/PycharmProjects/shape_predictor_68_face_landmarks.dat'
predictor = dlib.shape_predictor(predict_path)
count = 0
tfms = tfms_from_model(resnet34,
sz,
aug_tfms=transforms_side_on,
max_zoom=1.1)
data = ImageClassifierData.from_paths(PATH, tfms=tfms)
print(data.classes)
learn = ConvLearner.pretrained(arch, data, precompute=True)
print('loading requirements......')
print(
'This has been made by shaaran alias devshaaran, if you are using this code anywhere for research or educational purposes, please give reference.ENJOY!'
)
learn.precompute = False
#learn.fit(1e-1, 1)
learn.fit(1e-1, 3, cycle_len=1)
learn.load('224_all')
print('loading done !')
# Initialize some variablesface_locations = []
while True:
# Grab a single frame of video
ret, frame = video_capture.read()
# Resize frame of video to 1/4 size for faster face detection processing
small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale image
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)
for (x, y) in shape:
cv2.circle(frame, (x, y), 1, (0, 0, 255), -1)
# Find all the faces and face encodings in the current frame of video
face_locations = face_recognition.face_locations(small_frame,
model="cnn")
counts = 0
counts += 1
# Display the results
for top, right, bottom, left in face_locations:
# Scale back up face locations since the frame we detected in was scaled to 1/4 size
top *= 4
right *= 4
bottom *= 4
left *= 4
lower_red = np.array([0, 0, 253])
upper_red = np.array([0, 0, 255])
# Extract the region of the image that contains the face
face_image = frame[top:bottom, left:right]
mask = cv2.inRange(face_image, lower_red, upper_red)
res = cv2.bitwise_and(face_image, face_image, mask=mask)
#face_landmarks_list = face_recognition.face_landmarks(face_image)
#for face_landmarks in face_landmarks_list:
#for facial_feature in facial_features:
#d.line(face_landmarks[facial_feature], width=5)
#pil_image.show()
cv2.imshow('vid', face_image)
cv2.imshow('res', res)
count += 1
cv2.imwrite('0.jpg', res)
#cv2.imwrite((output_loc + '\\' + str(count)+ str(counts) + '.jpg'), res)
try:
# learn = ConvLearner.pretrained(arch, data, precompute=True)
trn_tfms, val_tfms = tfms_from_model(arch, sz)
im = val_tfms(open_image('0.jpg'))
learn.precompute = False
preds = learn.predict_array(im[None])
#print(preds)
print(data.classes[np.argmax(preds)])
except Exception as e:
print(e)
cv2.imshow('Video', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
video_capture.release()
cv2.destroyAllWindows()
import dlib
from imutils import face_utils
import numpy as np
import cv2
video_capture = cv2.VideoCapture(0)
face_detector = dlib.get_frontal_face_detector()
predictor_path = "../DlibData/shape_predictor_68_face_landmarks.dat"
face_predictor = dlib.shape_predictor(predictor_path)
while True:
ret, img = video_capture.read()
img = cv2.flip(img, 1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_detector(gray, 1)
for face in faces:
landmark = face_predictor(gray, face)
landmark = face_utils.shape_to_np(landmark)
for (i, (x, y)) in enumerate(landmark):
cv2.circle(img, (x, y), 1, (0, 0, 255), -1)
cv2.imshow("image", img)
if cv2.waitKey(1) == ord('q'):
break
def videoLoop(self):
try:
EARG = 0
MARG = 0
print("[INFO] Cargando paquete predictor...")
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(
"shape_predictor_68_face_landmarks.dat")
time.sleep(1.0)
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
(mStart, mEnd) = face_utils.FACIAL_LANDMARKS_IDXS["mouth"]
#Variables auxiliares
cont = 0
contaux = 0
SumaE = 0
contp = 0
i = 0
contM = 0
contMAu = 0
conpat = 1
#Variables para tiempos
t_ojos_cerrados = 0
t_ini_ojos_cerrados = 0
con_t_ojos = 0
con_gene = 0
contador_general_distraccion = 0
t_boca_abierta = 0
t_ini_boca_abierta = 0
con_t_boca = 0
t_distraccion = 0
self.t_global = 0
self.Facul = 0
self.Pro = 0
#Variables para Video
Cont_video = 1
self.Estado.set("ESPERANDO...")
self.Facultad.set("ESPERANDO...")
self.Tema.set("ESPERANDO...")
nombre = eg.enterbox(msg='Ingrese su nombre COMPLETO:',
title='Nombre del Usuario',
strip=True,
image=None)
id = eg.enterbox(msg='Ingrese su numero de Identificacion:',
title='Identificacion del Usuario',
strip=True,
image=None)
Lista_tiempo = []
Lista_boca = []
Lista_ojos = []
Lista_tema = []
Lista_estado = []
self.Estado_lista = "CONCENTRADO"
#Bucle principal para la obtencion de datos
messagebox.showinfo('Aviso', 'Calibracion de valores...')
while not self.stopEvent.is_set() and self.salir == 0:
self.Imprimir()
if contaux == 0:
print("\033[1;36m" +
"[INFO] Calibrando data para ojos abiertos..." +
'\033[0;m')
messagebox.showinfo(
'Aviso',
'Por favor, mantenga los ojos ABIERTOS durante 3 segundos'
)
t_inicial = time.monotonic()
elif contaux == 1:
print("\033[1;36m" +
"[INFO] Calibrando data para ojos cerrados..." +
'\033[0;m')
messagebox.showinfo(
'Aviso',
'Por favor, mantenga los ojos CERRADOS durante 3 segundos'
)
t_inicial = time.monotonic()
elif contaux == 2:
print("\033[1;36m" +
"[INFO] Calibrando data para boca cerrada..." +
'\033[0;m')
messagebox.showinfo(
'Aviso',
'Por favor, mantenga la boca CERRADA durante 3 segundos'
)
t_inicial = time.monotonic()
elif contaux == 3:
print("\033[1;36m" +
"[INFO] Calibrando data para boca abierta..." +
'\033[0;m')
messagebox.showinfo(
'Aviso',
'Por favor, mantenga la boca ABIERTA durante 3 segundos'
)
t_inicial = time.monotonic()
self.frame = self.Video.read()
self.frame = imutils.resize(self.frame, width=830)
gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 0)
for rect in rects:
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
Mouth = shape[mStart:mEnd]
EARG = round(self.eye_aspect_ratio(rightEye, leftEye), 4)
MARG = round(self.mouth_aspect_ratio(Mouth), 4)
if self.Empieza < 1:
self.Ear.set(str(round(EARG, 3)))
self.Mar.set(str(round(MARG, 3)))
else:
self.Ear.set("")
self.Mar.set("")
################################################################################################
if cont == 4 and self.Empieza == 1:
if con_gene == 0:
self.t_global = time.monotonic()
con_gene = 1
self.Inge.place_forget()
self.Arqui.place_forget()
self.EARL.place_forget()
self.EARL1.place_forget()
self.MARL.place_forget()
self.MARL1.place_forget()
self.Titulo.place_forget()
##############################################
##############################################
if EARG <= Umbral_ojos or MARG >= Umbral_boca:
self.Estado_lista = "POCA ATENCIÓN"
t_boca_abierta = time.monotonic() - t_ini_boca_abierta
t_ojos_cerrados = time.monotonic(
) - t_ini_ojos_cerrados
if t_boca_abierta >= t_ojos_cerrados:
t_distraccion = t_boca_abierta
else:
t_distraccion = t_ojos_cerrados
else:
self.Estado_lista = "CONCENTRADO"
##############################################
##############################################
if EARG <= Umbral_ojos and con_t_ojos == 0:
t_ini_ojos_cerrados = time.monotonic()
con_t_ojos = 1
#if (time.monotonic() - t_ini_ojos_cerrados) >=2:
# self.Estado_lista = "POCA ATENCIÓN"
elif EARG > Umbral_ojos and con_t_ojos == 1:
t_ojos_cerrados = time.monotonic(
) - t_ini_ojos_cerrados
con_t_ojos = 0
if t_ojos_cerrados >= 3:
contador_general_distraccion += 1
#self.Estado_lista = "CONCENTRADO"
t_ojos_cerrados = 0
if MARG >= Umbral_boca and con_t_boca == 0:
t_ini_boca_abierta = time.monotonic()
con_t_boca = 1
#if time.monotonic() - t_ini_boca_abierta >=2:
# self.Estado_lista = "POCA ATENCIÓN"
elif MARG < Umbral_boca and con_t_boca == 1:
t_boca_abierta = time.monotonic() - t_ini_boca_abierta
con_t_boca = 0
if t_boca_abierta > 3:
t_distraccion = t_distraccion + t_boca_abierta
contador_general_distraccion += 1
#self.Estado_lista = "CONCENTRADO"
#########################################################
self.Imprimir()
t_actual_lista = round((time.monotonic() - self.t_global),
4)
Lista_tiempo.append(t_actual_lista)
Lista_boca.append(MARG)
Lista_ojos.append(EARG)
Lista_tema.append(self.Tema_lista)
Lista_estado.append(self.Estado_lista)
###########################################################
###########################################################
if self.next == 1:
self.next = 0
self.Estado_lista = "CAMBIO DE TEMA"
t_actual_lista = round(
(time.monotonic() - self.t_global), 4)
Lista_tiempo.append(t_actual_lista)
Lista_boca.append(MARG)
Lista_ojos.append(EARG)
Lista_tema.append(self.Tema_lista)
Lista_estado.append(self.Estado_lista)
if Cont_video < 4:
self.Pro += 1
Cap = 1
self.video_clase.release()
self.video_clase = self.Video_Path(
self.Facul, self.Pro, Cap)
grabbed, frame = self.video_clase.read()
frame = imutils.resize(frame, width=950)
contador_general_distraccion = 0
Cont_video += 1
else:
messagebox.showinfo('Aviso', 'Fin de la sesion.')
break
if contador_general_distraccion >= 7:
self.Estado_lista = "UMBRAL DISTRACCIONES SUPERADO"
Op = messagebox.askyesno(
"Aviso!",
"Se detecto poco interes, ¿Desea cambiar de tema?")
if Op:
if Cont_video < 4:
self.Pro += 1
Cap = 1
self.video_clase.release()
self.video_clase = self.Video_Path(
self.Facul, self.Pro, Cap)
grabbed, frame = self.video_clase.read()
frame = imutils.resize(frame, width=950)
contador_general_distraccion = 0
Cont_video += 1
else:
messagebox.showinfo('Aviso',
'Fin de la sesion.')
break
else:
contador_general_distraccion = 0
grabbed, frame = self.video_clase.read()
self.panel.place(x=10, y=10)
frame = imutils.resize(frame, width=950)
if not grabbed:
if Cont_video < 4:
if contador_general_distraccion >= 4:
self.Pro += 1
Cap = 1
else:
Cap += 1
self.video_clase.release()
self.video_clase = self.Video_Path(
self.Facul, self.Pro, Cap)
grabbed, frame = self.video_clase.read()
frame = imutils.resize(frame, width=830)
contador_general_distraccion = 0
Cont_video += 1
else:
messagebox.showinfo('Aviso', 'Fin de la sesion.')
break
else:
#image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
image = Image.fromarray(image)
image = ImageTk.PhotoImage(image)
#######################################################################################################
else:
for (x, y) in shape:
cv2.circle(self.frame, (x, y), 1, (0, 0, 255), -1)
image = cv2.cvtColor(self.frame, cv2.COLOR_BGR2RGB)
image = Image.fromarray(image)
image = ImageTk.PhotoImage(image)
if self.panel is None:
self.panel = tki.Label(image=image,
relief="sunken",
borderwidth=3)
self.panel.image = image
self.panel.place(x=80, y=115)
else:
self.panel.configure(image=image,
relief="sunken",
borderwidth=3)
self.panel.image = image
t_act = time.monotonic() - t_inicial
#########################################################################################################
#Etapa inicial para determinar los valores para ojos y boca
#Ojos Abiertos
if cont == 0:
contaux = -1
SumaE = SumaE + EARG
contp = contp + 1
if t_act >= 3:
promEarAbi = SumaE / contp
print(
"[INFO] Valor de Eye Aspect Ratio (EAR) para ojos abiertos: ",
promEarAbi)
cont = 1
contaux = 1
contp = 0
SumaE = 0
#Ojos Cerrados
elif cont == 1:
contaux = -1
SumaE = SumaE + EARG
contp = contp + 1
if t_act >= 3:
promEarCe = SumaE / contp
print(
"[INFO] Valor de Eye Aspect Ratio (EAR) para ojos cerrados: ",
promEarCe)
cont = 2
contaux = 2
contp = 0
SumaE = 0
#Boca cerrada
elif cont == 2:
contaux = -1
SumaE = SumaE + MARG
contp = contp + 1
contM += 1
contMAu += 1
if t_act >= 3:
promMarCe = round((SumaE / contp), 4)
print(
"[INFO] Valor de Mouth Aspect Ratio (MAR) para boca cerrada: ",
promMarCe)
cont = 3
contaux = 3
contp = 0
SumaE = 0
#Boca ABIERTA
elif cont == 3:
contaux = -1
SumaE = SumaE + MARG
contp = contp + 1
contMAu += 1
if t_act >= 3:
promMarAbi = round((SumaE / contp), 4)
print(
"[INFO] Valor de Mouth Aspect Ratio (MAR) para boca abierta: ",
promMarAbi)
cont = 4
contaux = 4
contp = 0
SumaE = 0
Umbral_ojos = round(
(((promEarAbi + promEarCe) / 2) - 0.05), 4)
Umbral_boca = round(((promMarCe + promMarAbi) / 2), 4)
print("\033[1;36m" +
"[INFO] Umbrales establecidos..." + '\033[0;m')
print("[INFO] Valor Umbral para ojos: ", Umbral_ojos)
print("[INFO] Valor Umbral para boca: ", Umbral_boca)
print("\033[1;33m" +
"[INFO] Calibracion finalizada..." + '\033[0;m')
if self.loop:
break
self.Close()
self.t_global = time.monotonic() - self.t_global
Lista_tiempo.append(self.t_global)
Lista_boca.append(MARG)
Lista_ojos.append(EARG)
Lista_tema.append(self.Tema_lista)
Lista_estado.append(self.Estado_lista)
con_dist = 0
for n in Lista_estado:
if n is "POCA ATENCIÓN":
con_dist += 1
t_distraccion = con_dist * 0.12
print("[INFO] Tiempo Total: ", self.t_global)
print("[INFO] Tiempo Distraido: ", t_distraccion)
porcentaje = (round(t_distraccion / self.t_global, 4)) * 100
porce_2 = (round(
((self.t_global - t_distraccion) / self.t_global), 4)) * 100
print("[INFO] Porcentaje de distraccion: ", porcentaje, "%")
print("[INFO] Porcentaje de atencion: ", porce_2, "%")
self.Exportar(nombre, id, Lista_boca, Lista_ojos, Lista_tema,
Lista_estado, Lista_tiempo, porcentaje, porce_2,
promEarAbi, promEarCe, promMarCe, promMarAbi,
Umbral_ojos, Umbral_boca, t_distraccion)
except RuntimeError:
print("\033[1;31m" + "[ERROR] Error en RunTime " + '\033[0;m')
def dlibFaceDetector(inputFilePath, goodPath, badPath):
if printDetails:
file.writelines(getTime + "\t" +
"Histogram of Oriented Gradients: (neighbours:\t")
global badResult, goodResult
inputFile = cv2.imread(inputFilePath)
# ( Width [0], Height [1]
# inputFile = imutils.resize(inputFile, 500)
grayImage = cv2.cvtColor(inputFile, cv2.COLOR_BGR2GRAY)
width, height = inputFile.shape[:2]
print("width: " + str(width) + " height: " + str(height) + "\n")
rects = detector(grayImage, 1)
if len(rects) != 1:
cv2.imwrite(badPath + pathlib.Path(inputFilePath).name, inputFile)
badResult += 1
else:
goodResult += 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(grayImage, rect)
shape = face_utils.shape_to_np(shape)
# Pokazanie że wykrywa twarz - można pominąć
# cv2.rectangle(inputFile, (x, y), (x + w, y + int(h+(h*0.2))), (255, 0, 0), 2)
# convert dlib's rectangle to a OpenCV-style bounding box
# [i.e., (x, y, w, h)], then draw the face bounding box
# udowodnienie że twarz wykrywa
(x, y, w, h) = face_utils.rect_to_bb(rect)
if x < 0:
x = 0
elif x > width:
x = width - 1
if (y < 0):
y = 0
elif y > height:
y = height - 1
if w < 0:
w = 0
elif w > width:
w = width - 1
if (h < 0):
h = 0
elif h > height:
h = height - 1
cv2.rectangle(inputFile, (x, y), (x + w, y + h), (0, 255, 0), 2)
smart_h = int(h * chinHeightROI)
roi_color = inputFile[y:y + h, x:x + w]
#
# if smart_h > h:
# roi_color = inputFile[y:y + (height - 1), x:x + w]
# else:
# roi_color = inputFile[y:y + h + int(smart_h), x:x + w]
roi_gray = grayImage[y:y + height, x:x + w]
# croppedImage = cv2.clone
# cv2.imshow("Output", roi_color)
# cv2.waitKey(0)
# show the face number
# cv2.putText(inputFile, "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(inputFile, (x, y), 1, (0, 0, 255), -1)
# show the output image with the face detections + facial landmarks
cv2.imwrite(goodPath + pathlib.Path(inputFilePath).name, inputFile)
def run_detector():
# define two constants, one for the eye aspect ratio to indicate
# blink and then a second constant for the number of consecutive
# frames the eye must be below the threshold for to set off the
# alarm
EYE_AR_THRESH = 0.3
EYE_AR_CONSEC_FRAMES = 48
# initialize the frame counter as well as a boolean used to
# indicate if the alarm is going off
COUNTER = 0
ALARM_ON = False
# 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("shape_predictor_68_face_landmarks.dat")
# grab the indexes of the facial landmarks for the left and
# grab the indexes of the facial landmarks for the left and
# right eye, respectively
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
# start the video stream thread
print("[INFO] starting video stream thread...")
# vs = VideoStream(src=args["webcam"]).start()
# # time.sleep(1.0)
cam = cv2.VideoCapture(1 + cv2.CAP_DSHOW)
# Current time in millis
start_time = int(round(time.time() * 1000))
#time 30 seconds later in millis
stop_time = int(round(time.time() * 1000)) + 5000
# loop over frames from the video stream
while True:
# grab the frame from the threaded video file stream, resize
# it, and convert it to grayscale
# channels)
ret, frame = cam.read()
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
rects = detector(gray, 0)
# loop over the face detections
for rect in 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)
# extract the left and right eye coordinates, then use the
# coordinates to compute the eye aspect ratio for both eyes
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
# average the eye aspect ratio together for both eyes
ear = (leftEAR + rightEAR) / 2.0
# compute the convex hull for the left and right eye, then
# visualize each of the eyes
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)
# check to see if the eye aspect ratio is below the blink
# threshold, and if so, increment the blink frame counter
if ear < EYE_AR_THRESH:
COUNTER += 1
# if the eyes were closed for a sufficient number of
# then sound the alarm
if COUNTER >= EYE_AR_CONSEC_FRAMES:
# if the alarm is not on, turn it on
if not ALARM_ON:
ALARM_ON = True
# check to see if an alarm file was supplied,
# and if so, start a thread to have the alarm
# sound played in the background
t = Thread(target=sound_alarm, args=("alarm.wav", ))
t.deamon = True
t.start()
# draw an alarm on the frame
cv2.putText(frame, "DROWSINESS ALERT!", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# otherwise, the eye aspect ratio is not below the blink
# threshold, so reset the counter and alarm
else:
COUNTER = 0
ALARM_ON = False
# draw the computed eye aspect ratio on the frame to help
# with debugging and setting the correct eye aspect ratio
# thresholds and frame counters
cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# show the frame
cv2.imshow("Frame", frame)
cv2.waitKey(1) & 0xFF
# Time to run detector for
# Currently set to 1 seconds for testing
start_time = int(round(time.time() * 1000))
if start_time > stop_time:
break
# do a bit of cleanup
cv2.destroyAllWindows()
cam.release()
def camera(yVal):
cond = ''
while (True):
#Read each frame and flip it, and convert to grayscale
ret, frame = video_capture.read()
frame = cv2.flip(frame, 1)
frame = cv2.resize(frame, (300, 240))
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#Detect facial points through detector function
faces = detector(gray, 0)
#making reference lines
frame = cv2.line(frame, (0, yVal - 40), (1279, yVal - 40), (0, 0, 255),
2)
frame = cv2.line(frame, (0, yVal), (1279, yVal), (0, 0, 255), 2)
# cv2.imshow('EYE_DETECTION',frame )
#Detect facial points
for face in faces:
shape = predictor(gray, face)
shape = face_utils.shape_to_np(shape)
#Get array of coordinates of leftEye and rightEye
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
#Use hull to remove convex contour discrepencies and draw eye shape around eyes
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)
print(leftEye)
# print(leftEye[0][1]) #focus on y coordinate
cv2.imshow('EYE_DETECTION', frame)
if (leftEye[0][1]) >= yVal - 40 and (leftEye[0][1]) <= yVal:
cond = 'stop'
print("Good position")
# print(moveLinear(cond))
elif (leftEye[0][1]) < yVal - 40:
cond = 'up'
print("Table is moving up")
# moveLinear(cond)
elif (leftEye[0][1]) > yVal:
cond = 'down'
print("Table is moving down")
# moveLinear(cond)
#Show video feed
# cv2.imshow('EYE_DETECTION',frame )
if cv2.waitKey(1) & 0xFF == ord("q"):
time.sleep(2)
print('New Distance detecting... ')
return
elif len(list(list(faces))) > 1:
print("there are more than one person")
# mainVoice('There are more than one person in the frame')
elif len(list(list(faces))) == 0:
print('faceless')
def main():
cap = cv2.VideoCapture(0)
flag = 0
openEye = 0
final = ''
str = ''
finalString = []
L = []
closed = False
timer = 0
pts = deque(maxlen=512)
while True:
ret, frame = cap.read()
#cam1 = Camera()
#frame = cam1.get_frame()
frame = imutils.resize(frame, width=640)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
subjects = detect(gray, 0)
for subject in subjects:
shape = predict(gray, subject)
shape = face_utils.shape_to_np(shape) # converting to NumPy Array
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
ear = (leftEAR + rightEAR) / 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)
if ear < thresh: #closed eyes
flag += 1
pts.appendleft(flag)
openEye = 0
else:
openEye += 1
flag = 0
pts.appendleft(flag)
for i in range(1, len(pts)):
if pts[i] > pts[i - 1]:
#print(pts[i - 1], pts[i])
if pts[i] > 30 and pts[i] < 60:
print("Eyes have been closed for 50 frames!")
L.append("-")
pts = deque(maxlen=512)
break
elif pts[i] > 15 and pts[i] < 30:
print("Eyes have been closed for 20 frames!")
L.append(".")
pts = deque(maxlen=512)
break
elif pts[i] > 60:
print("Eyes have been closed for 60 frames!")
L.pop()
pts = deque(maxlen=512)
break
if (L != []):
print(L)
if openEye > 60:
if (L != []):
print(L)
str = convertMorseToText(''.join(L))
if str != None:
print(str)
finalString.append(str)
final = (''.join(finalString))
if str == None:
L = []
L = []
cv2.putText(frame, "Predicted : " + final, (10, 470),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
cv2.destroyAllWindows()
cap.stop()
def main():
global COUNTER
global TOTAL
shape_predictor_path = '../shape_predictor_68_face_landmarks.dat'
video_path = '../blink_test.mp4'
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(shape_predictor_path)
print('Load detector successfully')
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
vs = FileVideoStream(video_path).start()
file_stream = True
while True:
if file_stream and not vs.more():
break
frame = vs.read()
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
rects = detector(gray, 0)
for rect in 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)
# extract the left and right eye coordinates, then use the
# coordinates to compute the eye aspect ratio for both eyes
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
# average the eye aspect ratio together for both eyes
ear = (leftEAR + rightEAR) / 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)
if ear < EYE_AR_THRESH:
COUNTER += 1
else:
if COUNTER >= EYE_AR_CONSEC_FRAMES:
TOTAL += 1
COUNTER = 0
cv2.putText(frame, "Blinks: {}".format(TOTAL), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
cv2.destroyAllWindows()
vs.stop()
def navigationMode_1(self):
print(
"[INFO-NAVIGATION FUNCTION CLASS] : navigationMode_1() is called")
print("[STATUS] : NAVIGATION MODE 1 STARTED")
for f in self.stream:
self.image = f.array
print("[STATUS] : Reading Frame")
self.gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)
print("[STATUS] : accesss opencv")
self.rects = self.detector(self.gray, 0)
print("[STATUS] : accesss detector")
for rect in self.rects:
self.shape = self.predictor(self.gray, rect)
print("[STATUS] : LANDMARK POINT IS EXTRACTED")
self.shape = face_utils.shape_to_np(self.shape)
print("[STATUS] : LANDMARK POINT CONVERTED INTO NUMPY ARRAY")
self.mouthPoint = self.shape[self.mStart:self.mEnd]
print("[STATUS] : MOUTH PART IS EXTRACTED")
self.leftEye = self.shape[self.lStart:self.lEnd]
print("[STATUS] : LEFT EYE PART IS EXTRACTED")
self.rightEye = self.shape[self.rStart:self.rEnd]
print("[STATUS] : RIGHT EYE PART IS EXTRACTED")
self.mouthMAR = self._mouth_aspect_ratio(self.mouthPoint)
print("[STATUS] : MAR VALUE IS OBTAINED")
self.leftEAR = self.eye_aspect_ratio(self.leftEye)
print("[STATUS] : LEAR VALUE IS OBTAINED")
self.rightEAR = self.eye_aspect_ratio(self.rightEye)
print("[STATUS] : REAR VALUE IS OBTAINED")
#_____STAGE_1___________________________________________________________________________________________________
print("[STATUS] : STAGE 1")
if self.mouthMAR < self.MOUTH_AR_THRESH_CLOSED:
print("[STATUS] : MOUTH CLOSE FOR THIS FRAME")
self.closed_Counter += 1
self.open_Counter = 0
self.Mouth_Open_progress.emit(self.open_Counter)
self.Mouth_Close_progress.emit(self.closed_Counter)
else:
if self.mouthMAR > self.MOUTH_AR_THRESH_OPENED:
print("[STATUS] : MOUTH OPEN FOR THIS FRAME")
self.open_Counter += 1
self.closed_Counter = 0
self.Mouth_Open_progress.emit(self.open_Counter)
self.Mouth_Close_progress.emit(self.closed_Counter)
else:
print("[STATUS] : NO MOUTH DATA FOR THIS FRAME")
self.closed_Counter = 0
self.open_Counter = 0
self.Mouth_Open_progress.emit(self.open_Counter)
self.Mouth_Close_progress.emit(self.closed_Counter)
if self.leftEAR < self.EYE_AR_THRESH:
print("[STATUS] : LEFT EYE CLOSE FOR THIS FRAME")
self.LEFT_CLOSE_COUNTER += 1
self.LEFT_OPEN_COUNTER = 0
self.LeftEye_Open_progress.emit(self.LEFT_OPEN_COUNTER)
self.LeftEye_Close_progress.emit(self.LEFT_CLOSE_COUNTER)
else:
print("[STATUS] : LEFT EYE OPEN FOR THIS FRAME")
self.LEFT_OPEN_COUNTER += 1
self.LEFT_CLOSE_COUNTER = 0
self.LeftEye_Open_progress.emit(self.LEFT_OPEN_COUNTER)
self.LeftEye_Close_progress.emit(self.LEFT_CLOSE_COUNTER)
if self.rightEAR < self.EYE_AR_THRESH:
print("[STATUS] : RIGHT EYE CLOSE FOR THIS FRAME")
self.RIGHT_CLOSE_COUNTER += 1
self.RIGHT_OPEN_COUNTER = 0
self.RightEye_Open_progress.emit(self.RIGHT_OPEN_COUNTER)
self.RightEye_Close_progress.emit(self.RIGHT_CLOSE_COUNTER)
else:
print("[STATUS] : RIGHT EYE OPEN FOR THIS FRAME")
self.RIGHT_OPEN_COUNTER += 1
self.RIGHT_CLOSE_COUNTER = 0
self.RightEye_Open_progress.emit(self.RIGHT_OPEN_COUNTER)
self.RightEye_Close_progress.emit(self.RIGHT_CLOSE_COUNTER)
#_____STAGE_2___________________________________________________________________________________________________
print("[STATUS] : STAGE 2")
if self.LEFT_CLOSE_COUNTER >= self.EYE_AR_CONSEC_FRAMES:
print("[STATUS] : LEFT EYE CLOSE VALIDATED")
self.CURRENT_LEFT_EYE_STATE = "OPEN"
self.LEFT_EYE_OPEN_TOTAL += 1
self.LEFT_EYE_CLOSE_TOTAL = 0
self.LEFT_CLOSE_COUNTER = 0
self.LEFT_OPEN_COUNTER = 0
self.LeftEye_State_progress.emit(
self.CURRENT_LEFT_EYE_STATE)
else:
if self.LEFT_OPEN_COUNTER >= self.EYE_AR_CONSEC_FRAMES:
print("[STATUS] : LEFT EYE OPEN VALIDATED")
self.CURRENT_LEFT_EYE_STATE = "CLOSE"
self.LEFT_EYE_CLOSE_TOTAL += 1
self.LEFT_EYE_OPEN_TOTAL = 0
self.LEFT_OPEN_COUNTER = 0
self.LEFT_CLOSE_TOTAL = 0
self.LeftEye_State_progress.emit(
self.CURRENT_LEFT_EYE_STATE)
else:
print("[STATUS] : LEFT EYE NOT DEFINED")
self.CURRENT_LEFT_EYE_STATE = "NOT DEFINED"
self.LeftEye_State_progress.emit(
self.CURRENT_LEFT_EYE_STATE)
if self.RIGHT_CLOSE_COUNTER >= self.EYE_AR_CONSEC_FRAMES:
print("[STATUS] : RIGHT EYE CLOSE VALIDATED")
self.CURRENT_RIGHT_EYE_STATE = "OPEN"
self.RIGHT_EYE_OPEN_TOTAL += 1
self.RIGHT_EYE_CLOSE_TOTAL = 0
self.RIGHT_CLOSE_COUNTER = 0
self.RIGHT_OPEN_COUNTER = 0
self.RightEye_State_progress.emit(
self.CURRENT_RIGHT_EYE_STATE)
else:
if self.RIGHT_OPEN_COUNTER >= self.EYE_AR_CONSEC_FRAMES:
print("[STATUS] : RIGHT EYE OPEN VALIDATED")
self.CURRENT_RIGHT_EYE_STATE = "CLOSE"
self.RIGHT_EYE_CLOSE_TOTAL += 1
self.RIGHT_EYE_OPEN_TOTAL = 0
self.RIGHT_OPEN_COUNTER = 0
self.RIGHT_CLOSE_COUNTER = 0
self.RightEye_State_progress.emit(
self.CURRENT_RIGHT_EYE_STATE)
else:
print("[STATUS] : RIGHT EYE NOT DEFINED")
self.CURRENT_RIGHT_EYE_STATE = "NOT DEFINED"
self.RightEye_State_progress.emit(
self.CURRENT_RIGHT_EYE_STATE)
print("[STATUS] : RIGHT EYE NOT DEFINED SIGNAL SENT")
if self.open_Counter >= self.MOUTH_AR_CONSEC_FRAME:
print("[STATUS] : MOUTH OPEN VALIDATED")
self.CURRENT_MOUTH_STATE = "OPEN"
self.TOTAL_MOUTH_OPEN_TOTAL += 1
self.TOTAL_MOUTH_CLOSE_TOTAL = 0
self.Mouth_State_progress.emit(self.CURRENT_MOUTH_STATE)
else:
if self.closed_Counter >= self.MOUTH_AR_CONSEC_FRAME:
print("[STATUS] : MOUTH CLOSE VALIDATED")
self.CURRENT_MOUTH_STATE = "CLOSE"
self.TOTAL_MOUTH_CLOSE_TOTAL += 1
self.TOTAL_MOUTH_OPEN_TOTAL = 0
self.Mouth_State_progress.emit(
self.CURRENT_MOUTH_STATE)
else:
print("[STATUS] : MOUTH NOT DEFINED VALIDATED")
self.CURRENT_MOUTH_STATE = "NOT DEFINED"
print(
"[STATUS] : MOUTH NOT DEFINED VALIDATED SIGNAL WILL BE SENT"
)
self.Mouth_State_progress.emit(
self.CURRENT_MOUTH_STATE)
print(
"[STATUS] : MOUTH NOT DEFINED VALIDATED SIGNAL SENT"
)
#_____STAGE_3___________________________________________________________________________________________________
print("[STATUS] : DEBUGGER POINT 11_")
if self.LEFT_EYE_OPEN_TOTAL != 1 or self.LEFT_EYE_CLOSE_TOTAL != 1:
self.PREVIOUS_LEFT_EYE_STATE = self.CURRENT_LEFT_EYE_STATE
if self.RIGHT_EYE_OPEN_TOTAL != 1 or self.RIGHT_EYE_CLOSE_TOTAL != 1:
self.PREVIOUS_RIGHT_EYE_STATE = self.CURRENT_RIGHT_EYE_STATE
if self.TOTAL_MOUTH_CLOSE_TOTAL != 1 or self.TOTAL_MOUTH_OPEN_TOTAL != 1:
self.PREVIOUS_MOUTH_STATE = self.CURRENT_MOUTH_STATE
if self.PREVIOUS_LEFT_EYE_STATE == self.CURRENT_LEFT_EYE_STATE and \
self.PREVIOUS_RIGHT_EYE_STATE == self.CURRENT_RIGHT_EYE_STATE and self.PREVIOUS_MOUTH_STATE == self.CURRENT_MOUTH_STATE :
self.patternCaller += 1
else:
self.patternCaller = 0
if self.patternCaller > 4:
self.patternResult = eightCombo(self,
CURRENT_LEFT_EYE_STATE,
CURRENT_RIGHT_EYE_STATE,
CURRENT_MOUTH_STATE)
self.Pattern_progress.emit(self.patternResult)
self.finished.emit()
self.rawCapture.close()
self.camera.close()
self.rawCapture.truncate(0)
print("[STATUS] : DONE THIS FRAME.NEXT FRAME")
self.rawCapture.close()
self.camera.close()
def blink_detector(output_textfile, input_video):
Q = Queue(maxsize=7)
FRAME_MARGIN_BTW_2BLINKS = 3
MIN_AMPLITUDE = 0.04
MOUTH_AR_THRESH = 0.35
MOUTH_AR_THRESH_ALERT = 0.30
MOUTH_AR_CONSEC_FRAMES = 20
EPSILON = 0.01 # for discrete derivative (avoiding zero derivative)
class Blink():
def __init__(self):
self.start = 0 #frame
self.startEAR = 1
self.peak = 0 #frame
self.peakEAR = 1
self.end = 0 #frame
self.endEAR = 0
self.amplitude = (self.startEAR + self.endEAR -
2 * self.peakEAR) / 2
self.duration = self.end - self.start + 1
self.EAR_of_FOI = 0 #FrameOfInterest
self.values = []
self.velocity = 0 #Eye-closing velocity
def eye_aspect_ratio(eye):
# compute the euclidean distances between the two sets of
# vertical eye landmarks (x, y)-coordinates
A = dist.euclidean(eye[1], eye[5])
B = dist.euclidean(eye[2], eye[4])
# compute the euclidean distance between the horizontal
# eye landmark (x, y)-coordinates
C = dist.euclidean(eye[0], eye[3])
if C < 0.1: #practical finetuning due to possible numerical issue as a result of optical flow
ear = 0.3
else:
# compute the eye aspect ratio
ear = (A + B) / (2.0 * C)
if ear > 0.45: #practical finetuning due to possible numerical issue as a result of optical flow
ear = 0.45
# return the eye aspect ratio
return ear
def mouth_aspect_ratio(mouth):
A = dist.euclidean(mouth[14], mouth[18])
C = dist.euclidean(mouth[12], mouth[16])
if C < 0.1: #practical finetuning
mar = 0.2
else:
# compute the mouth aspect ratio
mar = (A) / (C)
# return the mouth aspect ratio
return mar
def EMERGENCY(ear, COUNTER):
if ear < 0.21:
COUNTER += 1
if COUNTER >= 50:
print('EMERGENCY SITUATION (EYES TOO LONG CLOSED)')
print(COUNTER)
COUNTER = 0
else:
COUNTER = 0
return COUNTER
def Linear_Interpolate(start, end, N):
m = (end - start) / (N + 1)
x = np.linspace(1, N, N)
y = m * (x - 0) + start
return list(y)
def Ultimate_Blink_Check():
#Given the input "values", retrieve blinks and their quantities
retrieved_blinks = []
MISSED_BLINKS = False
values = np.asarray(Last_Blink.values)
THRESHOLD = 0.4 * np.min(values) + 0.6 * np.max(
values) # this is to split extrema in highs and lows
N = len(values)
Derivative = values[1:N] - values[0:N -
1] #[-1 1] is used for derivative
i = np.where(Derivative == 0)
if len(i[0]) != 0:
for k in i[0]:
if k == 0:
Derivative[0] = -EPSILON
else:
Derivative[k] = EPSILON * Derivative[k - 1]
M = N - 1 #len(Derivative)
ZeroCrossing = Derivative[1:M] * Derivative[0:M - 1]
x = np.where(ZeroCrossing < 0)
xtrema_index = x[0] + 1
XtremaEAR = values[xtrema_index]
Updown = np.ones(
len(xtrema_index)) # 1 means high, -1 means low for each extremum
Updown[
XtremaEAR <
THRESHOLD] = -1 #this says if the extremum occurs in the upper/lower half of signal
#concatenate the beginning and end of the signal as positive high extrema
Updown = np.concatenate(([1], Updown, [1]))
XtremaEAR = np.concatenate(([values[0]], XtremaEAR, [values[N - 1]]))
xtrema_index = np.concatenate(([0], xtrema_index, [N - 1]))
##################################################################
Updown_XeroCrossing = Updown[1:len(Updown)] * Updown[0:len(Updown) - 1]
jump_index = np.where(Updown_XeroCrossing < 0)
numberOfblinks = int(len(jump_index[0]) / 2)
selected_EAR_First = XtremaEAR[jump_index[0]]
selected_EAR_Sec = XtremaEAR[jump_index[0] + 1]
selected_index_First = xtrema_index[jump_index[0]]
selected_index_Sec = xtrema_index[jump_index[0] + 1]
if numberOfblinks > 1:
MISSED_BLINKS = True
if numberOfblinks == 0:
print(Updown, Last_Blink.duration)
print(values)
print(Derivative)
for j in range(numberOfblinks):
detected_blink = Blink()
detected_blink.start = selected_index_First[2 * j]
detected_blink.peak = selected_index_Sec[2 * j]
detected_blink.end = selected_index_Sec[2 * j + 1]
detected_blink.startEAR = selected_EAR_First[2 * j]
detected_blink.peakEAR = selected_EAR_Sec[2 * j]
detected_blink.endEAR = selected_EAR_Sec[2 * j + 1]
detected_blink.duration = detected_blink.end - detected_blink.start + 1
detected_blink.amplitude = 0.5 * (
detected_blink.startEAR - detected_blink.peakEAR) + 0.5 * (
detected_blink.endEAR - detected_blink.peakEAR)
detected_blink.velocity = (
detected_blink.endEAR - selected_EAR_First[2 * j + 1]) / (
detected_blink.end - selected_index_First[2 * j + 1] + 1
) #eye opening ave velocity
retrieved_blinks.append(detected_blink)
return MISSED_BLINKS, retrieved_blinks
def Blink_Tracker(EAR, IF_Closed_Eyes, Counter4blinks, TOTAL_BLINKS, skip):
BLINK_READY = False
#If the eyes are closed
if int(IF_Closed_Eyes) == 1:
Current_Blink.values.append(EAR)
Current_Blink.EAR_of_FOI = EAR #Save to use later
if Counter4blinks > 0:
skip = False
if Counter4blinks == 0:
Current_Blink.startEAR = EAR #EAR_series[6] is the EAR for the frame of interest(the middle one)
Current_Blink.start = reference_frame - 6 #reference-6 points to the frame of interest which will be the 'start' of the blink
Counter4blinks += 1
if Current_Blink.peakEAR >= EAR: #deciding the min point of the EAR signal
Current_Blink.peakEAR = EAR
Current_Blink.peak = reference_frame - 6
# otherwise, the eyes are open in this frame
else:
if Counter4blinks < 2 and skip == False: # Wait to approve or reject the last blink
if Last_Blink.duration > 15:
FRAME_MARGIN_BTW_2BLINKS = 8
else:
FRAME_MARGIN_BTW_2BLINKS = 1
if ((reference_frame - 6) -
Last_Blink.end) > FRAME_MARGIN_BTW_2BLINKS:
# Check so the prev blink signal is not monotonic or too small (noise)
if Last_Blink.peakEAR < Last_Blink.startEAR and Last_Blink.peakEAR < Last_Blink.endEAR and Last_Blink.amplitude > MIN_AMPLITUDE and Last_Blink.start < Last_Blink.peak:
if ((Last_Blink.startEAR - Last_Blink.peakEAR) >
(Last_Blink.endEAR - Last_Blink.peakEAR) * 0.25 and
(Last_Blink.startEAR - Last_Blink.peakEAR) * 0.25 <
(Last_Blink.endEAR -
Last_Blink.peakEAR)): # the amplitude is balanced
BLINK_READY = True
#####THE ULTIMATE BLINK Check
Last_Blink.values = signal.convolve1d(
Last_Blink.values, [1 / 3.0, 1 / 3.0, 1 / 3.0],
mode='nearest')
# Last_Blink.values=signal.median_filter(Last_Blink.values, 3, mode='reflect') # smoothing the signal
[MISSED_BLINKS,
retrieved_blinks] = Ultimate_Blink_Check()
#####
TOTAL_BLINKS = TOTAL_BLINKS + len(
retrieved_blinks
) # Finally, approving/counting the previous blink candidate
###Now You can count on the info of the last separate and valid blink and analyze it
Counter4blinks = 0
print("MISSED BLINKS= {}".format(
len(retrieved_blinks)))
return retrieved_blinks, int(
TOTAL_BLINKS
), Counter4blinks, BLINK_READY, skip
else:
skip = True
print('rejected due to imbalance')
else:
skip = True
print('rejected due to noise,magnitude is {}'.format(
Last_Blink.amplitude))
print(Last_Blink.start < Last_Blink.peak)
# if the eyes were closed for a sufficient number of frames (2 or more)
# then this is a valid CANDIDATE for a blink
if Counter4blinks > 1:
Current_Blink.end = reference_frame - 7 #reference-7 points to the last frame that eyes were closed
Current_Blink.endEAR = Current_Blink.EAR_of_FOI
Current_Blink.amplitude = (Current_Blink.startEAR +
Current_Blink.endEAR -
2 * Current_Blink.peakEAR) / 2
Current_Blink.duration = Current_Blink.end - Current_Blink.start + 1
if Last_Blink.duration > 15:
FRAME_MARGIN_BTW_2BLINKS = 8
else:
FRAME_MARGIN_BTW_2BLINKS = 1
if (
Current_Blink.start - Last_Blink.end
) <= FRAME_MARGIN_BTW_2BLINKS + 1: #Merging two close blinks
print('Merging...')
frames_in_between = Current_Blink.start - Last_Blink.end - 1
print(Current_Blink.start, Last_Blink.end,
frames_in_between)
valuesBTW = Linear_Interpolate(Last_Blink.endEAR,
Current_Blink.startEAR,
frames_in_between)
Last_Blink.values = Last_Blink.values + valuesBTW + Current_Blink.values
Last_Blink.end = Current_Blink.end # update the end
Last_Blink.endEAR = Current_Blink.endEAR
if Last_Blink.peakEAR > Current_Blink.peakEAR: #update the peak
Last_Blink.peakEAR = Current_Blink.peakEAR
Last_Blink.peak = Current_Blink.peak
#update duration and amplitude
Last_Blink.amplitude = (Last_Blink.startEAR +
Last_Blink.endEAR -
2 * Last_Blink.peakEAR) / 2
Last_Blink.duration = Last_Blink.end - Last_Blink.start + 1
else: #Should not Merge (a Separate blink)
Last_Blink.values = Current_Blink.values #update the EAR list
Last_Blink.end = Current_Blink.end # update the end
Last_Blink.endEAR = Current_Blink.endEAR
Last_Blink.start = Current_Blink.start #update the start
Last_Blink.startEAR = Current_Blink.startEAR
Last_Blink.peakEAR = Current_Blink.peakEAR #update the peak
Last_Blink.peak = Current_Blink.peak
Last_Blink.amplitude = Current_Blink.amplitude
Last_Blink.duration = Current_Blink.duration
# reset the eye frame counter
Counter4blinks = 0
retrieved_blinks = 0
return retrieved_blinks, int(
TOTAL_BLINKS), Counter4blinks, BLINK_READY, skip
print('hello')
#
# initialize the frame counters and the total number of yawnings
COUNTER = 0
MCOUNTER = 0
TOTAL = 0
MTOTAL = 0
TOTAL_BLINKS = 0
Counter4blinks = 0
skip = False # to make sure a blink is not counted twice in the Blink_Tracker function
Last_Blink = Blink()
print("[INFO] loading facial landmark predictor...")
detector = dlib.get_frontal_face_detector()
#Load the Facial Landmark Detector
predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
#Load the Blink Detector
loaded_svm = pickle.load(
open('Trained_SVM_C=1000_gamma=0.1_for 7kNegSample.sav', 'rb'))
# grab the indexes of the facial landmarks for the left and
# right eye, respectively
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
(mStart, mEnd) = face_utils.FACIAL_LANDMARKS_IDXS["mouth"]
print("[INFO] starting video stream thread...")
lk_params = dict(winSize=(13, 13),
maxLevel=2,
criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
10, 0.03))
EAR_series = np.zeros([13])
Frame_series = np.linspace(1, 13, 13)
reference_frame = 0
First_frame = True
top = tk.Tk()
frame1 = Frame(top)
frame1.grid(row=0, column=0)
fig = plt.figure()
ax = fig.add_subplot(111)
plot_frame = FigureCanvasTkAgg(fig, master=frame1)
plot_frame.get_tk_widget().pack(side=tk.BOTTOM, expand=True)
plt.ylim([0.0, 0.5])
line, = ax.plot(Frame_series, EAR_series)
plot_frame.draw()
# loop over frames from the video stream
stream = cv2.VideoCapture(path)
start = datetime.datetime.now()
number_of_frames = 0
while True:
(grabbed, frame) = stream.read()
if not grabbed:
print('not grabbed')
print(number_of_frames)
break
frame = imutils.resize(frame, width=450)
# To Rotate by 90 degreees
# rows=np.shape(frame)[0]
# cols = np.shape(frame)[1]
# M = cv2.getRotationMatrix2D((cols / 2, rows / 2),-90, 1)
# frame = cv2.warpAffine(frame, M, (cols, rows))
gray = cv2.cvtColor(
frame, cv2.COLOR_BGR2GRAY) #Brighten the image(Gamma correction)
reference_frame = reference_frame + 1
gray = adjust_gamma(gray, gamma=1.5)
Q.put(frame)
end = datetime.datetime.now()
ElapsedTime = (end - start).total_seconds()
# detect faces in the grayscale frame
rects = detector(gray, 0)
if (np.size(rects) != 0):
number_of_frames = number_of_frames + 1 # we only consider frames that face is detected
First_frame = False
old_gray = gray.copy()
# determine the facial landmarks for the face region, then
# convert the facial landmark (x, y)-coordinates to a NumPy
# array
shape = predictor(gray, rects[0])
shape = face_utils.shape_to_np(shape)
###############YAWNING##################
#######################################
Mouth = shape[mStart:mEnd]
MAR = mouth_aspect_ratio(Mouth)
MouthHull = cv2.convexHull(Mouth)
cv2.drawContours(frame, [MouthHull], -1, (255, 0, 0), 1)
if MAR > MOUTH_AR_THRESH:
MCOUNTER += 1
elif MAR < MOUTH_AR_THRESH_ALERT:
if MCOUNTER >= MOUTH_AR_CONSEC_FRAMES:
MTOTAL += 1
MCOUNTER = 0
##############YAWNING####################
#########################################
# extract the left and right eye coordinates, then use the
# coordinates to compute the eye aspect ratio for both eyes
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
# average the eye aspect ratio together for both eyes
ear = (leftEAR + rightEAR) / 2.0
#EAR_series[reference_frame]=ear
EAR_series = shift(EAR_series, -1, cval=ear)
# compute the convex hull for the left and right eye, then
# visualize each of the eyes
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)
############HANDLING THE EMERGENCY SITATION################
###########################################################
###########################################################
COUNTER = EMERGENCY(ear, COUNTER)
# EMERGENCY SITUATION (EYES TOO LONG CLOSED) ALERT THE DRIVER IMMEDIATELY
############HANDLING THE EMERGENCY SITATION################
###########################################################
###########################################################
if Q.full() and (
reference_frame > 15
): #to make sure the frame of interest for the EAR vector is int the mid
EAR_table = EAR_series
IF_Closed_Eyes = loaded_svm.predict(EAR_series.reshape(1, -1))
if Counter4blinks == 0:
Current_Blink = Blink()
retrieved_blinks, TOTAL_BLINKS, Counter4blinks, BLINK_READY, skip = Blink_Tracker(
EAR_series[6], IF_Closed_Eyes, Counter4blinks,
TOTAL_BLINKS, skip)
if (BLINK_READY == True):
reference_frame = 20 #initialize to a random number to avoid overflow in large numbers
skip = True
#####
BLINK_FRAME_FREQ = TOTAL_BLINKS / number_of_frames
for detected_blink in retrieved_blinks:
print(detected_blink.amplitude, Last_Blink.amplitude)
print(detected_blink.duration, detected_blink.velocity)
print('-------------------')
if (detected_blink.velocity > 0):
with open(output_file, 'ab') as f_handle:
f_handle.write(b'\n')
np.savetxt(f_handle, [
TOTAL_BLINKS, BLINK_FRAME_FREQ * 100,
detected_blink.amplitude,
detected_blink.duration,
detected_blink.velocity
],
delimiter=', ',
newline=' ',
fmt='%.4f')
Last_Blink.end = -10 # re initialization
#####
line.set_ydata(EAR_series)
plot_frame.draw()
frameMinus7 = Q.get()
cv2.imshow("Frame", frameMinus7)
elif Q.full(
): #just to make way for the new input of the Q when the Q is full
junk = Q.get()
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key != 0xFF:
break
#Does not detect any face
else:
###################Using Optical Flow############
################### (Optional) ############
st = 0
st2 = 0
if (First_frame == False):
leftEye = leftEye.astype(np.float32)
rightEye = rightEye.astype(np.float32)
p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, gray, leftEye,
None, **lk_params)
p2, st2, err2 = cv2.calcOpticalFlowPyrLK(
old_gray, gray, rightEye, None, **lk_params)
if np.sum(st) + np.sum(st2) == 12 and First_frame == False:
p1 = np.round(p1).astype(np.int)
p2 = np.round(p2).astype(np.int)
#print(p1)
leftEAR = eye_aspect_ratio(p1)
rightEAR = eye_aspect_ratio(p2)
ear = (leftEAR + rightEAR) / 2.0
EAR_series = shift(EAR_series, -1, cval=ear)
#EAR_series[reference_frame] = ear
leftEyeHull = cv2.convexHull(p1)
rightEyeHull = cv2.convexHull(p2)
cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)
cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)
old_gray = gray.copy()
leftEye = p1
rightEye = p2
############HANDLING THE EMERGENCY SITATION################
###########################################################
###########################################################
COUNTER = EMERGENCY(ear, COUNTER)
############HANDLING THE EMERGENCY SITATION################
###########################################################
###########################################################
###################Using Optical Flow############
################### ############
if Q.full() and (reference_frame > 15):
EAR_table = EAR_series
IF_Closed_Eyes = loaded_svm.predict(EAR_series.reshape(1, -1))
if Counter4blinks == 0:
Current_Blink = Blink()
retrieved_blinks, TOTAL_BLINKS, Counter4blinks, BLINK_READY, skip = Blink_Tracker(
EAR_series[6], IF_Closed_Eyes, Counter4blinks,
TOTAL_BLINKS, skip)
if (BLINK_READY == True):
reference_frame = 20 #initialize to a random number to avoid overflow in large numbers
skip = True
#####
BLINK_FRAME_FREQ = TOTAL_BLINKS / number_of_frames
for detected_blink in retrieved_blinks:
print(detected_blink.amplitude, Last_Blink.amplitude)
print(detected_blink.duration, Last_Blink.duration)
print('-------------------')
with open(output_file, 'ab') as f_handle:
f_handle.write(b'\n')
np.savetxt(f_handle, [
TOTAL_BLINKS, BLINK_FRAME_FREQ * 100,
detected_blink.amplitude,
detected_blink.duration,
detected_blink.velocity
],
delimiter=', ',
newline=' ',
fmt='%.4f')
Last_Blink.end = -10 # re initialization
#####
line.set_ydata(EAR_series)
plot_frame.draw()
frameMinus7 = Q.get()
cv2.imshow("Frame", frameMinus7)
elif Q.full():
junk = Q.get()
key = cv2.waitKey(1) & 0xFF
if key != 0xFF:
break
# do a bit of cleanup
stream.release()
cv2.destroyAllWindows()
def navigationMode_2(self):
print(
"[INFO-NAVIGATION FUNCTION CLASS] : navigationMode_1() is called")
print("[STATUS] : NAVIGATION MODE 2 STARTED")
for f in self.stream:
self.image = f.array
print("[STATUS] : Reading Frame")
self.gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)
print("[STATUS] : accesss opencv")
self.rects = self.detector(self.gray, 0)
print("[STATUS] : accesss detector")
for rect in self.rects:
self.shape = self.predictor(self.gray, rect)
print("[STATUS] : LANDMARK POINT IS EXTRACTED")
self.shape = face_utils.shape_to_np(self.shape)
print("[STATUS] : LANDMARK POINT CONVERTED INTO NUMPY ARRAY")
self.leftEye = self.shape[self.lStart:self.lEnd]
print("[STATUS] : LEFT EYE PART IS EXTRACTED")
self.rightEye = self.shape[self.rStart:self.rEnd]
print("[STATUS] : RIGHT EYE PART IS EXTRACTED")
self.leftEAR = self.eye_aspect_ratio(self.leftEye)
print("[STATUS] : LEAR VALUE IS OBTAINED")
self.rightEAR = self.eye_aspect_ratio(self.rightEye)
print("[STATUS] : REAR VALUE IS OBTAINED")
#_____STAGE_1___________________________________________________________________________________________________
print("[STATUS] : STAGE 1")
if self.leftEAR < self.EYE_AR_THRESH:
print("[STATUS] : LEFT EYE CLOSE FOR THIS FRAME")
self.LEFT_CLOSE_COUNTER += 1
self.LEFT_OPEN_COUNTER = 0
self.LeftEye_Open_progress.emit(self.LEFT_OPEN_COUNTER)
self.LeftEye_Close_progress.emit(self.LEFT_CLOSE_COUNTER)
else:
print("[STATUS] : LEFT EYE OPEN FOR THIS FRAME")
self.LEFT_OPEN_COUNTER += 1
self.LEFT_CLOSE_COUNTER = 0
self.LeftEye_Open_progress.emit(self.LEFT_OPEN_COUNTER)
self.LeftEye_Close_progress.emit(self.LEFT_CLOSE_COUNTER)
if self.rightEAR < self.EYE_AR_THRESH:
print("[STATUS] : RIGHT EYE CLOSE FOR THIS FRAME")
self.RIGHT_CLOSE_COUNTER += 1
self.RIGHT_OPEN_COUNTER = 0
self.RightEye_Open_progress.emit(self.RIGHT_OPEN_COUNTER)
self.RightEye_Close_progress.emit(self.RIGHT_CLOSE_COUNTER)
else:
print("[STATUS] : RIGHT EYE OPEN FOR THIS FRAME")
self.RIGHT_OPEN_COUNTER += 1
self.RIGHT_CLOSE_COUNTER = 0
self.RightEye_Open_progress.emit(self.RIGHT_OPEN_COUNTER)
self.RightEye_Close_progress.emit(self.RIGHT_CLOSE_COUNTER)
#_____STAGE_2___________________________________________________________________________________________________
print("[STATUS] : STAGE 2")
if self.LEFT_CLOSE_COUNTER >= self.EYE_AR_CONSEC_FRAMES:
print("[STATUS] : LEFT EYE CLOSE VALIDATED")
self.CURRENT_LEFT_EYE_STATE = "OPEN"
self.LEFT_EYE_OPEN_TOTAL += 1
self.LEFT_EYE_CLOSE_TOTAL = 0
self.LEFT_CLOSE_COUNTER = 0
self.LEFT_OPEN_COUNTER = 0
self.LeftEye_State_progress.emit(
self.CURRENT_LEFT_EYE_STATE)
else:
if self.LEFT_OPEN_COUNTER >= self.EYE_AR_CONSEC_FRAMES:
print("[STATUS] : LEFT EYE OPEN VALIDATED")
self.CURRENT_LEFT_EYE_STATE = "CLOSE"
self.LEFT_EYE_CLOSE_TOTAL += 1
self.LEFT_EYE_OPEN_TOTAL = 0
self.LEFT_OPEN_COUNTER = 0
self.LEFT_CLOSE_TOTAL = 0
self.LeftEye_State_progress.emit(
self.CURRENT_LEFT_EYE_STATE)
else:
print("[STATUS] : LEFT EYE NOT DEFINED")
self.CURRENT_LEFT_EYE_STATE = "NOT DEFINED"
self.LeftEye_State_progress.emit(
self.CURRENT_LEFT_EYE_STATE)
if self.RIGHT_CLOSE_COUNTER >= self.EYE_AR_CONSEC_FRAMES:
print("[STATUS] : RIGHT EYE CLOSE VALIDATED")
self.CURRENT_RIGHT_EYE_STATE = "OPEN"
self.RIGHT_EYE_OPEN_TOTAL += 1
self.RIGHT_EYE_CLOSE_TOTAL = 0
self.RIGHT_CLOSE_COUNTER = 0
self.RIGHT_OPEN_COUNTER = 0
self.RightEye_State_progress.emit(
self.CURRENT_RIGHT_EYE_STATE)
else:
if self.RIGHT_OPEN_COUNTER >= self.EYE_AR_CONSEC_FRAMES:
print("[STATUS] : RIGHT EYE OPEN VALIDATED")
self.CURRENT_RIGHT_EYE_STATE = "CLOSE"
self.RIGHT_EYE_CLOSE_TOTAL += 1
self.RIGHT_EYE_OPEN_TOTAL = 0
self.RIGHT_OPEN_COUNTER = 0
self.RIGHT_CLOSE_COUNTER = 0
self.RightEye_State_progress.emit(
self.CURRENT_RIGHT_EYE_STATE)
else:
print("[STATUS] : RIGHT EYE NOT DEFINED")
self.CURRENT_RIGHT_EYE_STATE = "NOT DEFINED"
self.RightEye_State_progress.emit(
self.CURRENT_RIGHT_EYE_STATE)
print("[STATUS] : RIGHT EYE NOT DEFINED SIGNAL SENT")
#_____STAGE_3___________________________________________________________________________________________________
print("[STATUS] : DEBUGGER POINT 11_")
if self.LEFT_EYE_OPEN_TOTAL != 1 or self.LEFT_EYE_CLOSE_TOTAL != 1:
self.PREVIOUS_LEFT_EYE_STATE = self.CURRENT_LEFT_EYE_STATE
print("[STATUS] : DEBUGGER POINT 12_")
if self.RIGHT_EYE_OPEN_TOTAL != 1 or self.RIGHT_EYE_CLOSE_TOTAL != 1:
self.PREVIOUS_RIGHT_EYE_STATE = self.CURRENT_RIGHT_EYE_STATE
print("[STATUS] : DEBUGGER POINT 13_")
if self.PREVIOUS_LEFT_EYE_STATE == self.CURRENT_LEFT_EYE_STATE and \
self.PREVIOUS_RIGHT_EYE_STATE == self.CURRENT_RIGHT_EYE_STATE :
self.patternCaller += 1
else:
self.patternCaller = 0
if self.patternCaller > 3:
self.patternResult = threeCombo(self, left_Eye_state,
right_Eye_state)
if self.patternResult == 'PATTERN_11':
self.rawCapture.close()
self.camera.close()
else:
print("signal emitter")
self.rawCapture.truncate(0)
print("[INFO] : DONE THIS FRAME.NEXT FRAME")
self.rawCapture.close()
self.camera.close()
def eye_state():
vs = VideoStream(src=0).start()
time.sleep(1.0)
COUNTER = 0
while True:
img = vs.read()
img = imutils.resize(img, width=700)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = detector(gray, 0)
for face in faces:
shapes = predictor(gray, face)
shapes = face_utils.shape_to_np(shapes)
eye_img_l, eye_rect_l = crop_eye(gray, eye_points=shapes[36:42])
eye_img_r, eye_rect_r = crop_eye(gray, eye_points=shapes[42:48])
eye_img_l = cv2.resize(eye_img_l, dsize=IMG_SIZE)
eye_img_r = cv2.resize(eye_img_r, dsize=IMG_SIZE)
eye_img_r = cv2.flip(eye_img_r, flipCode=1)
# cv2.imshow('l', eye_img_l)
# cv2.imshow('r', eye_img_r)
eye_input_l = eye_img_l.copy().reshape(
(1, IMG_SIZE[1], IMG_SIZE[0], 1)).astype(np.float32) / 255.
eye_input_r = eye_img_r.copy().reshape(
(1, IMG_SIZE[1], IMG_SIZE[0], 1)).astype(np.float32) / 255.
pred_l = model.predict(eye_input_l)
pred_r = model.predict(eye_input_r)
# visualize
state_l = 'O %.1f' if pred_l > 0.1 else '- %.1f'
state_r = 'O %.1f' if pred_r > 0.1 else '- %.1f'
state_l = state_l % pred_l
state_r = state_r % pred_r
cv2.rectangle(img,
pt1=tuple(eye_rect_l[0:2]),
pt2=tuple(eye_rect_l[2:4]),
color=(255, 255, 255),
thickness=2)
cv2.rectangle(img,
pt1=tuple(eye_rect_r[0:2]),
pt2=tuple(eye_rect_r[2:4]),
color=(255, 255, 255),
thickness=2)
cv2.putText(img, state_l, tuple(eye_rect_l[0:2]),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
cv2.putText(img, state_r, tuple(eye_rect_r[0:2]),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
if state_l[0] == '-' and state_r[0] == '-':
COUNTER += 1
print(COUNTER)
if COUNTER >= 50:
cv2.putText(img, "You Died", (230, 250),
cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 7)
else:
COUNTER = 0
cv2.imshow('result', img)
if cv2.waitKey(1) == ord('q'):
break
cv2.destroyAllWindows()
vs.stop()
def find_eyes_in_rect(frame, rect):
shapes = shape_predictor(frame, rect)
shapes = face_utils.shape_to_np(shapes)
left_eye = shapes[left_eye_start:left_eye_end]
right_eye = shapes[right_eye_start:right_eye_end]
return (left_eye, right_eye)
tick = cv2.getTickCount()
ret, rgb = cap.read()
gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
faces = face_cascade.detectMultiScale(gray,
scaleFactor=1.11,
minNeighbors=3,
minSize=(100, 100))
if len(faces) == 1:
x, y, w, h = faces[0, :]
cv2.rectangle(rgb, (x, y), (x + w, y + h), (255, 0, 0), 2)
face = dlib.rectangle(x, y, x + w, y + h)
face_parts = face_parts_detector(gray, face)
face_parts = face_utils.shape_to_np(face_parts)
for i, ((x, y)) in enumerate(face_parts[:]):
cv2.circle(rgb, (x, y), 1, (0, 255, 0), -1)
cv2.putText(rgb, str(i), (x + 2, y - 2), cv2.FONT_HERSHEY_SIMPLEX,
0.3, (0, 255, 0), 1)
fps = cv2.getTickFrequency() / (cv2.getTickCount() - tick)
cv2.putText(rgb, "FPS:{} ".format(int(fps)), (10, 50),
cv2.FONT_HERSHEY_PLAIN, 3, (0, 0, 255), 2, cv2.LINE_AA)
cv2.imshow('frame', rgb)
if cv2.waitKey(1) == 27:
break # esc to quit
cap.release()
def calculate_features(path, out_path=''):
frame = cv2.imread(path, cv2.IMREAD_COLOR)
landmarks = {}
# detect faces in the grayscale frame
rects = face_detector(frame, 0)
# loop over the face detections
for rect in rects:
# determine the facial landmarks for the face region, then
# convert the facial landmark (x, y)-coordinates to a NumPy
# array
shape = landmark_shape_predictor(frame, rect)
shape = face_utils.shape_to_np(shape)
# loop over the (x, y)-coordinates for the facial landmarks
# and draw them on the image
c = 0
for (x, y) in shape:
c += 1
if c in pointsConsider:
landmarks[c] = (x, y)
cv2.putText(frame, str(c), (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.25,
(0, 0, 255), 1, cv2.LINE_AA)
current_eyebrow_left = 0
current_eyebrow_right = 0
current_angle_with_nose_left = 0
current_angle_with_nose_right = 0
mouth_width_distance = 0
mouth_height_distance = 0
for pair in pairs:
p1 = pair[0]
p2 = pair[1]
try:
l1 = landmarks[p1]
l2 = landmarks[p2]
distance = get_distance(l1, l2)
lip_normal_distance = get_distance(landmarks[34], landmarks[52])
eye_norm_distance_left = get_distance(landmarks[40], landmarks[22])
eye_norm_distance_right = get_distance(landmarks[43],
landmarks[23])
if pair in leftEyebrow:
current_eyebrow_left += distance / eye_norm_distance_left
elif pair in rightEyebrow:
current_eyebrow_right += distance / eye_norm_distance_right
elif pair in mouthWidth:
mouth_width_distance = distance / lip_normal_distance
elif pair in mouthHeight:
mouth_height_distance = distance / lip_normal_distance
elif pair in angleWithNoseLeft:
current_angle_with_nose_left += distance / lip_normal_distance
elif pair in angleWithNoseRight:
current_angle_with_nose_right += distance / lip_normal_distance
cv2.line(frame, l1, l2, (0, 255, 0), 1, cv2.LINE_AA)
except KeyError:
print('not found pairs 1', p1)
print('not found pairs 2', p2)
out = np.array([
current_eyebrow_left, current_eyebrow_right,
current_angle_with_nose_left, current_angle_with_nose_right,
mouth_width_distance, mouth_height_distance
])
# print('out:', out)
if len(out_path) > 0:
cv2.imwrite(out_path, frame)
return out
vs = VideoStream(src=0).start()
fileStream = False
time.sleep(1.0)
while(1):
if fileStream and not vs.more():
break
frame = vs.read()
frame = imutils.resize(frame, width=600)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 0)
#print(len(rects))
for rect in rects:
print('-'*20)
print(rect)
shape = predictor(gray, rect)
points = face_utils.shape_to_np(shape)# convert the facial landmark (x, y)-coordinates to a NumPy array
# points = shape.parts()
leftEye = points[lStart:lEnd]
rightEye = points[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
print('leftEAR = {0}'.format(leftEAR))
print('rightEAR = {0}'.format(rightEAR))
ear = (leftEAR+rightEAR)/2.0
leftEyeHull = cv2.convexHull(leftEye)
#print(leftEyeHull)
rightEyeHull = cv2.convexHull(rightEye)
xmaxl=max(leftEyeHull, key=lambda x: x[0][0])[0][0]
def cvloop(run_event):
global panelA
global SPRITES
dir_ = "./sprites/flyes/"
flies = [f for f in listdir(dir_) if isfile(join(dir_, f))] #image of flies to make the "animation"
i = 0
video_capture = cv2.VideoCapture(0) #read from webcam
(x,y,w,h) = (0,0,10,10) #whatever initial values
#Filters path
detector = dlib.get_frontal_face_detector()
#Facial landmarks
print("[INFO] loading facial landmark predictor...")
model = "filters/shape_predictor_68_face_landmarks.dat"
predictor = dlib.shape_predictor(model) # link to model: http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2
while run_event.is_set(): #while the thread is active we loop
ret, image = video_capture.read()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = detector(gray, 0)
for face in faces: #if there are faces
(x,y,w,h) = (face.left(), face.top(), face.width(), face.height())
# *** Facial Landmarks detection
shape = predictor(gray, face)
shape = face_utils.shape_to_np(shape)
incl = calculate_inclination(shape[17], shape[26]) #inclination based on eyebrows
# condition to see if mouth is open
is_mouth_open = (shape[66][1] -shape[62][1]) >= 10 #y coordiantes of landmark points of lips
#hat condition
if SPRITES[0]:
apply_sprite(image, "./sprites/hat.png",w,x,y, incl)
#mustache condition
if SPRITES[1]:
(x1,y1,w1,h1) = get_face_boundbox(shape, 6)
apply_sprite(image, "./sprites/mustache.png",w1,x1,y1, incl)
#glasses condition
if SPRITES[3]:
(x3,y3,_,h3) = get_face_boundbox(shape, 1)
apply_sprite(image, "./sprites/glasses.png",w,x,y3, incl, ontop = False)
#flies condition
if SPRITES[2]:
#to make the "animation" we read each time a different image of that folder
# the images are placed in the correct order to give the animation impresion
apply_sprite(image, dir_+flies[i],w,x,y, incl)
i+=1
i = 0 if i >= len(flies) else i #when done with all images of that folder, begin again
#doggy condition
(x0,y0,w0,h0) = get_face_boundbox(shape, 6) #bound box of mouth
if SPRITES[4]:
(x3,y3,w3,h3) = get_face_boundbox(shape, 5) #nose
apply_sprite(image, "./sprites/doggy_nose.png",w3,x3,y3, incl, ontop = False)
apply_sprite(image, "./sprites/doggy_ears.png",w,x,y, incl)
if is_mouth_open:
apply_sprite(image, "./sprites/doggy_tongue.png",w0,x0,y0, incl, ontop = False)
else:
if is_mouth_open:
apply_sprite(image, "./sprites/rainbow.png",w0,x0,y0, incl, ontop = False)
# OpenCV represents image as BGR; PIL but RGB, we need to change the chanel order
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# conerts to PIL format
image = Image.fromarray(image)
# Converts to a TK format to visualize it in the GUI
image = ImageTk.PhotoImage(image)
# Actualize the image in the panel to show it
panelA.configure(image=image)
panelA.image = image
video_capture.release()
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(".\shape_predictor_68_face_landmarks.dat"
) # Dat file is the crux of the code
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_68_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_68_IDXS["right_eye"]
cap = cv2.VideoCapture(0)
frame_count = 0
while True:
ret, frame = cap.read()
cv2.namedWindow("VideoCapture", cv2.WINDOW_NORMAL)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = detector(gray, 0)
for face in faces:
shape = predictor(gray, face)
shape = face_utils.shape_to_np(shape) # converting to NumPy Array
left_Eye = shape[lStart:lEnd]
right_Eye = shape[rStart:rEnd]
left_EAR = eye_aspect_ratio(left_Eye)
right_EAR = eye_aspect_ratio(right_Eye)
ear = (left_EAR + right_EAR) / 2.0
leftEyeHull = cv2.convexHull(left_Eye)
rightEyeHull = cv2.convexHull(right_Eye)
cv2.drawContours(frame, [leftEyeHull], -1, (255, 0, 85), 1)
cv2.drawContours(frame, [rightEyeHull], -1, (255, 0, 85), 1)
if ear < min_ear:
frame_count += 1
print(frame_count)
if frame_count >= max_frame:
cv2.putText(frame,
"!!!!!!! ALERT! YOU ARE ABOUT TO SLEEP !!!!!!!",
def calculate(self,frame):
frame = imutils.resize(frame, width=640)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
subjects = self.detect(gray, 0)
for subject in subjects:
shape = self.predict(gray, subject)
shape = face_utils.shape_to_np(shape) # converting to NumPy Array
leftEye = shape[self.lStart:self.lEnd]
rightEye = shape[self.rStart:self.rEnd]
leftEAR = self.eye_aspect_ratio(leftEye)
rightEAR = self.eye_aspect_ratio(rightEye)
ear = (leftEAR + rightEAR) / 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)
if ear < self.thresh: # closed eyes
self.flag += 1
self.pts.appendleft(self.flag)
self.openEye = 0
else:
self.openEye += 1
self.flag = 0
self.pts.appendleft(self.flag)
for i in range(1, len(self.pts)):
if self.pts[i] > self.pts[i - 1]:
# print(pts[i - 1], pts[i])
if self.pts[i] > 30 and self.pts[i] < 60:
print("Eyes have been closed for 50 frames! - Print '-'")
log("Eyes have been closed for 50 frames!")
self.L.append("-")
self.pts = deque(maxlen=512)
break
elif self.pts[i] > 15 and self.pts[i] < 30:
print("Eyes have been closed for 20 frames!")
log("Eyes have been closed for 20 frames! - Print '.'")
self.L.append(".")
self.pts = deque(maxlen=512)
break
elif self.pts[i] > 60:
print("Eyes have been closed for 60 frames!")
log("Eyes have been closed for 60 frames! - Remove morse character")
self.L.pop()
self.pts = deque(maxlen=512)
break
if (self.L != []):
print(self.L)
if self.openEye > 60:
if (self.L != []):
print(self.L)
self.str = convertMorseToText(''.join(self.L))
if self.str != None:
print(self.str)
self.finalString.append(self.str)
self.final = ''.join(self.finalString)
if self.str == None:
self.L = []
self.L = []
cv2.putText(frame, "Predicted : " + self.final, (10, 470),
cv2.FONT_HERSHEY_DUPLEX, 0.7, (52, 152, 219), 2)
return frame
# it, and convert it to grayscale
# channels)
frame = vs.read()
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
rects = detector(gray, 0)
# loop over the face detections
for rect in 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)
# extract the left and right eye coordinates, then use the
# coordinates to compute the eye aspect ratio for both eyes
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
# average the eye aspect ratio together for both eyes
ear = (leftEAR + rightEAR) / 2.0
# compute the convex hull for the left and right eye, then
# visualize each of the eyes
leftEyeHull = cv2.convexHull(leftEye)
rightEyeHull = cv2.convexHull(rightEye)
def main():
EYE_AR_THRESH = 0.3
EYE_AR_CONSEC_FRAMES = 30
ALARM_ON = False
COUNTER = 0
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
# print("-> Starting Video Stream")
vs = VideoStream(0).start()
# vs= VideoStream(usePiCamera=True).start() //For Raspberry Pi
time.sleep(1.0)
while True:
frame = vs.read()
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
rects = detector(gray, 0)
# loop over the face detections
for rect in rects:
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
eye = final_ear(shape)
ear = eye[0]
leftEye = eye[1]
rightEye = eye[2]
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)
if ear < EYE_AR_THRESH:
COUNTER += 1
if COUNTER >= EYE_AR_CONSEC_FRAMES:
if not ALARM_ON:
ALARM_ON = True
t = Thread(target=sound_alarm,
args=(["alarm"],))
t.deamon = True
t.start()
cv2.putText(frame, "DROWSINESS ALERT!", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
else:
COUNTER = 0
ALARM_ON = False
cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# show the frame
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
# do a bit of cleanup
cv2.destroyAllWindows()
vs.stop()
ret, frame = cap.read()
if ret == False:
print(
'Failed to capture frame from camera. Check camera index in cv2.VideoCapture(0) \n'
)
break
# cv2.imshow(frame)
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 0)
for rect in rects:
# determine the facial landmarks for #face region
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape) # converting to numpy array
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
ear = (leftEAR + rightEAR) / 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)
if ear < EYE_AR_THRESH:
def head_posture(rect, gray, predictor, size):
shape0 = predictor(gray, rect)
shape0 = np.array(face_utils.shape_to_np(shape0))
# 2D image points. If you change the image, you need to change vector
image_points = np.array(
[
(shape0[33, :]), # Nose tip
(shape0[8, :]), # Chin
(shape0[36, :]), # Left eye left corner
(shape0[45, :]), # Right eye right corne
(shape0[48, :]), # Left Mouth corner
(shape0[54, :]) # Right mouth corner
],
dtype="double")
# 3D model points.
model_points = np.array([
(0.0, 0.0, 0.0), # Nose tip
(0.0, -330.0, -65.0), # Chin
(-225.0, 170.0, -135.0), # Left eye left corner
(225.0, 170.0, -135.0), # Right eye right corne
(-150.0, -150.0, -125.0), # Left Mouth corner
(150.0, -150.0, -125.0) # Right mouth corner
])
# Camera internals
focal_length = size[1]
center = (size[1] / 2, size[0] / 2)
camera_matrix = np.array([[focal_length, 0, center[0]],
[0, focal_length, center[1]], [0, 0, 1]],
dtype="double")
# print("Camera Matrix :\n {0}".format(camera_matrix))
dist_coeffs = np.zeros((4, 1)) # Assuming no lens distortion
(success, setting.rotation_vector,
setting.translation_vector) = cv2.solvePnP(model_points,
image_points,
camera_matrix,
dist_coeffs,
flags=cv2.SOLVEPNP_ITERATIVE)
# print("Rotation Vector:\n {0}".format(setting.rotation_vector))
# print("Translation Vector:\n {0}".format(setting.translation_vector))
# Project a 3D point (0, 0, 1000.0) onto the image plane.
# We use this to draw a line sticking out of the nose
(nose_end_point2D,
jacobian) = cv2.projectPoints(np.array([
(0.0, 0.0, 1000.0)
]), setting.rotation_vector, setting.translation_vector, camera_matrix,
dist_coeffs)
for p in image_points:
cv2.circle(setting.frame, (int(p[0]), int(p[1])), 3, (0, 0, 255), -1)
if setting.translation_vector[1][0] < 300 and setting.translation_vector[
1][0] > 0:
setting.HP_CODE = 1
elif setting.translation_vector[1][
0] >= 300 and setting.translation_vector[1][0] <= 600:
setting.HP_CODE = 0
elif setting.translation_vector[1][0] > 600:
setting.HP_CODE = 2
elif setting.translation_vector[1][0] < 0:
setting.HP_CODE = 3
def StartDetection(CameraQueue,FrameQueue,RectQueue,FacepointQueue,SpeakerQueue):
print("[INFO] loading facial landmark predictor...")
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor("../models/dlib/shape_predictor_68_face_landmarks.dat")
#fourcc = cv2.VideoWriter_fourcc(*'XVID')
#outVideo = cv2.VideoWriter('outputRoboy.mp4',fourcc, 20.0, (800,533))
vs = cv2.VideoCapture(0)
detect_net = load_net("../darknet/cfg/yolo.cfg", "../darknet/yolo.weights", 0)
detect_meta = load_meta("../darknet/cfg/coco.data")
counter = 0
while True:
"""
grab the frame from the threaded video stream, resize it to
have a maximum width of 800 pixels, and convert it to
grayscale"""
ok,frame = vs.read()
if not ok:
break;
#frame = imutils.resize(frame, width=800)\
frame = frame[0:376, 0:500]
detectObjects(frame,detect_net,detect_meta)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
rects = detector(gray, 0)
# loop over the face detections
counter=0
facepoints = dict()
SpeakerDict = {}
try:
SpeakerDict = SpeakerQueue.get_nowait()
except:
pass
for rect in rects:
counter +=1
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(frame,str(counter),(rect.left()-10,rect.top()-10),\
font, 2, (200,255,155), 13,\
cv2.LINE_AA)
p1 = (int(rect.left()),int(rect.top()))
p2 = (int(rect.right()),int(rect.bottom()))
cv2.rectangle(frame, p1, p2, (0,0,255,10))
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
facepoints[counter] =shape
#print ("Rect from face_detect:",rect,"Detected face width: ",rect.right()-rect.left()," height:",rect.bottom()-rect.top())
if SpeakerDict:
#print("Person:",SpeakerDict[counter])
try:
if SpeakerDict[counter]:
for (x, y) in shape:
cv2.circle(frame, (x, y), 2, (0, 255,0), -1)
else:
for (x, y) in shape:
cv2.circle(frame, (x, y), 2, (0, 0,255), -1)
except:
pass
else:
for (x, y) in shape:
cv2.circle(frame, (x, y), 2, (0, 0, 255), -1)
FacepointQueue.put(pickle.dumps(facepoints))
FrameQueue.put(frame)
# outVideo.write(frame)
RectQueue.put(rects)
break
image = cv2.cvtColor(cv2.flip(image, 1), cv2.COLOR_BGR2RGB)
image.flags.writeable = False
results = pose.process(image)
image.flags.writeable = True
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
image = cv2.resize(image, dsize=(0, 0), fx=fx, fy=fy)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
try:
face = detector(gray)[0]
# for face in faces:
shapes = predictor(gray, face)
shapes = face_utils.shape_to_np(shapes)
eye_img_l, eye_rect_l = crop_eye(gray, eye_points=shapes[36:42])
eye_img_r, eye_rect_r = crop_eye(gray, eye_points=shapes[42:48])
eye_img_l = cv2.resize(eye_img_l, dsize=IMG_SIZE)
eye_img_r = cv2.resize(eye_img_r, dsize=IMG_SIZE)
eye_img_r = cv2.flip(eye_img_r, flipCode=1)
eye_input_l = eye_img_l.copy().reshape(
(1, IMG_SIZE[1], IMG_SIZE[0], 1)).astype(np.float32) / 255.
eye_input_r = eye_img_r.copy().reshape(
(1, IMG_SIZE[1], IMG_SIZE[0], 1)).astype(np.float32) / 255.
pred_l = model.predict(eye_input_l)
pred_r = model.predict(eye_input_r)
(rightStart, rightEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"] # Gets right eye indices
vs = VideoStream(0).start()
time.sleep(1.0) # pause for feed
while True:
frame = vs.read() # Get frame from video
# frame = imutils.resize(frame, width=450) # Resize the frame
# frame = cv2.resize(frame,(frame.height,450))
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # Convert to grayscale
# Detect faces in image
faces = detector.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30),
flags=cv2.CASCADE_SCALE_IMAGE)
for (x, y, w, h) in faces:
face = dlib.rectangle(int(x), int(y), int(x + w), int(y + h)) # Creates a rectangle for the face
shape = predictor(gray, face) # Get facial coordinates
shape = face_utils.shape_to_np(shape) # Convert facial cartesian coordinates to a numpy array
# extract the left and right eye coordinates, then use the
# coordinates to compute the eye aspect ratio for both eyes
leftEye = shape[leftStart:leftEnd] # Slice of coordinates corresponding to left eye
rightEye = shape[rightStart:rightEnd] # Slice of coordinates corresponding to right eye
leftAspectRatio = aspectRatio(leftEye) # Get aspect ratio of left eye
rightAspectRatio = aspectRatio(rightEye) # Get aspect ratio of left eye
avgAspectRatio = (leftAspectRatio + rightAspectRatio) / 2.0 # Average of both eyes)
cv2.drawContours(frame, [cv2.convexHull(leftEye)], -1, (0, 255, 0), 1) # Drawing contour around the left eye
cv2.drawContours(frame, [cv2.convexHull(rightEye)], -1, (0, 255, 0), 1) # Drawing contour around the right eye
if avgAspectRatio < ASPECT_RATIO_THRESHOLD: # If Aspect ratio dips below threshold
counter += 1
print(counter)
if counter >= MAX_CONSEC_FRAMES: # If eyes are closed for long enough
# if the alarm is not on, turn it on
#if not is_alarm_on:
def cvloop(run_event):
global panelA
global SPRITES
global image_path
i = 0
# video_capture = cv2.VideoCapture(0) #read from webcam
# video_capture = cv2.VideoCapture('http://192.168.43.247:4747/mjpegfeed') #read from webcam
video_capture = cv2.VideoCapture(
'http://192.168.0.100:4747/mjpegfeed') #read from webcam
(x, y, w, h) = (0, 0, 10, 10) #whatever initial values
#Filters path
detector = dlib.get_frontal_face_detector()
model = "C:\\Users\\amitt\\Desktop\\Folder\\E-Dressing-master\\Project\\data\\shape_predictor_68_face_landmarks.dat"
predictor = dlib.shape_predictor(
model
) # link to model: http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2
while run_event.is_set():
ret, image = video_capture.read()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = detector(gray, 0)
for face in faces:
(x, y, w, h) = (face.left(), face.top(), face.width(),
face.height())
shape = predictor(gray, face)
shape = face_utils.shape_to_np(shape)
incl = calculate_inclination(
shape[17], shape[26]) #inclination based on eyebrows
# condition to see if mouth is open
is_mouth_open = (shape[66][1] - shape[62][1]
) >= 10 #y coordiantes of landmark points of lips
if SPRITES[0]:
apply_sprite(image, image_path, w, x, y + 40, incl, ontop=True)
if SPRITES[1]:
(x1, y1, w1, h1) = get_face_boundbox(shape, 6)
apply_sprite(image, image_path, w1, x1, y1 + 275, incl)
if SPRITES[3]:
(x3, y3, _, h3) = get_face_boundbox(shape, 1)
apply_sprite(image, image_path, w, x, y3, incl, ontop=False)
(x0, y0, w0, h0) = get_face_boundbox(shape, 6) #bound box of mouth
if SPRITES[4]:
(x3, y3, w3, h3) = get_face_boundbox(shape, 7) # ears
apply_sprite(image, image_path, w3, x3 - 20, y3 + 25, incl)
(x3, y3, w3, h3) = get_face_boundbox(shape, 8) # ears
apply_sprite(image, image_path, w3, x3 + 20, y3 + 25, incl)
if SPRITES[5]:
findRects = []
upperPath = "C:\\Users\\amitt\\Desktop\\Folder\\E-Dressing-master\\Project\\data\\haarcascade_upperbody.xml"
imageGray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
upperCascade = cv2.CascadeClassifier(upperPath)
upperRect = upperCascade.detectMultiScale(imageGray,
scaleFactor=1.1,
minNeighbors=1,
minSize=(1, 1))
if len(upperRect) > 0:
findRects.append(upperRect[0])
for obj in findRects:
# img = cv2.rectangle(img, (obj[0],obj[1]), (obj[0]+obj[2], obj[1]+obj[3]), (0, 255, 0), 2)
sprite = cv2.imread(image_path, -1)
image = draw_sprite(image, sprite, obj[0], obj[1])
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = Image.fromarray(image)
image = ImageTk.PhotoImage(image)
panelA.configure(image=image)
panelA.image = image
video_capture.release()
def rotateImage(imageObj, correctionAngle, nosePoint):
rotationMatrix = cv2.getRotationMatrix2D(nosePoint, correctionAngle, 1.0)
return cv2.warpAffine(imageObj, rotationMatrix, (imageObj.shape[1], imageObj.shape[0]), flags=cv2.INTER_LINEAR)
for person in os.listdir("Users"):
recognizer = cv2.face.createLBPHFaceRecognizer()
for faceImageFile in os.listdir("Users/" + person + "/originals"):
if faceImageFile.endswith(".png"):
gray = cv2.imread("Users/" + person + "/originals/" + faceImageFile,
cv2.CV_8UC1) # gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 1)
for (j, rect) in enumerate(rects):
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
angle = calculateFaceTilt(Point(shape[39]), Point(shape[42]))
gray = rotateImage(gray, angle, tuple(shape[33]))
# gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 1)
# loop over the face detections
for (k, rect) in enumerate(rects):
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
eye = Point(shape[37])
eyebrow = Point(shape[19])
left = Point(min(shape, key=itemgetter(0)))
top = Point(min(shape, key=itemgetter(1)))
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("lala")
# print(type(face))
# print(face)
# 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)
numpy_array = np.array(final)
#Prdiction by the MOdel
prediction = model.predict([numpy_array])[0]
(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) )
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)
#Here wil be the code for best expression...
# print(self.int_count)
if(count_interested > self.int_count):
print("BEST frame has been caught")
file_storage = best_int_path + "\\" + "BEST_PIC" + '.jpg'
cv2.imwrite(file_storage, gray)
# global self.int_count
print(self.int_count)
self.int_count = count_interested
print("best frame has been save to record")
#sending detected faces list to app.py file on to be displayed the browser
return (my_list)
else:
break
def main_loop(self):
"""
Single iteration of the application's main loop.
"""
# Get current image frame from the camera
frame = self.camera.get_frame()
self.h, self.w, _c = frame.shape
# display unaltered frame
# imshow("Original",frame)
# set current image frame to the processor's input
self.processor.frame_in = frame
# process the image frame to perform all needed analysis
self.processor.run()
# collect the output frame for display
output_frame = self.processor.frame_out
# show the processed/annotated output frame
imshow("Processed", output_frame)
# create and/or update the raw data display if needed
global smileneighbour, mqLoop, smilecount, eyetot
# if self.bpm_plot:
# self.make_bpm_plot()
x = str(datetime.datetime.now())
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rects = self.detector(gray, 0)
#####Record self-report#####
key = cv2.waitKey(1) & 0xFF
if key == ord("."):
c.write(str(md.datestr2num(x)) + " " + str(500) + "\n")
############################
for rect in rects:
shape = self.predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
shape2 = shape.copy()
newline = ""
for (w,z) in shape2:
cv2.circle(frame, (w, z), 1, (0, 0, 255), -1)
new = str((w,z)) + " "
newline += new
#######################
########Raw Data#######
#######################
raw.write(str(md.datestr2num(x)) + newline + "\n")
#######################
######New Things#######
leftBrow = shape[21]
rightBrow = shape[22]
distance = dist.euclidean(leftBrow, rightBrow)
upper1 = shape[37]
lower1 = shape[41]
right1 = shape[38]
upper2 = shape[43]
lower2 = shape[47]
right2 = shape[44]
average = (dist.euclidean(upper1, lower1) * dist.euclidean(upper1, right1) + dist.euclidean(upper2,
lower2) * dist.euclidean(
upper2, right2))
leftmouth = shape[48]
rightmouth = shape[54]
upperlip = shape[62]
lowerlip = shape[66]
##########End##########
#######################
#Time, Frown, Eye size, Mouth width, Mouth heigth, Brow Raise, Length of face, and Width of face
all.write(str(md.datestr2num(x)) + " " + str(distance) + " " + str(average) + " " + str(
dist.euclidean(leftmouth, rightmouth)) + " " + str(dist.euclidean(upperlip, lowerlip)) + " " + str(
(dist.euclidean(shape[24], shape[44]) + dist.euclidean(shape[19], shape[37]))) + " " + str(dist.euclidean(shape[27], shape[8])) + " " + str(dist.euclidean(shape[2], shape[14])) + "\n")
#######################
######Single File######
cv2.imshow("Frame", frame)
if mqLoop >= 1:
sm.write(str(md.datestr2num(x)) + " " + str(smileneighbour) + "\n")
e.write(str(md.datestr2num(x)) + " " + str(eyetot) + "\n")
hr.write(str(md.datestr2num(x)) + " " + str(self.processor.show_bpm_text.bpm) + "\n")
smileneighbour += 2 * eyetot
smileneighbour /= 100
if (self.processor.show_bpm_text.bpm) > dhr:
# print (self.processor.fft.samples[-1]/2, self.processor.fft.samples[-1]-dhr/2)
# overbeat = (self.processor.fft.samples[-1]-dhr)*(self.processor.fft.samples[-1]-dhr)
smileneighbour += (self.processor.show_bpm_text.bpm - dhr)
f.write(str(md.datestr2num(x)) + " " + str(smileneighbour) + "\n")
mqLoop = 0
else:
mqLoop += 0.9
img = cv.QueryFrame(capture)
smileneighbour = 0
eyetot = 0
if img:
image = DetectRedEyes(img, faceCascade, smileCascade, eyeCascade)
cv.ShowImage("camera", image)
# handle any key presses
self.key_handler()
def sendFaceImages(self):
self.statusLabel.set_text("Obrada uzoraka")
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor("ldm.dat")
for i in range(0, 7):
gray = cv2.imread("Camera/Resources/" + str(i) + '.png', cv2.CV_8UC1)
#gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 1)
# loop over the face detections
for (j, rect) in enumerate(rects):
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
angle = self.calculateFaceTilt(Point(shape[39]), Point(shape[42]))
gray = self.rotateImage(gray, angle, tuple(shape[33]))
#gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 1)
# loop over the face detections
for (k, rect) in enumerate(rects):
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
eye = Point(shape[37])
eyebrow = Point(shape[19])
left = Point(min(shape, key=itemgetter(0)))
top = Point(min(shape, key=itemgetter(1)))
right = Point(max(shape, key=itemgetter(0)))
bottom = Point(max(shape, key=itemgetter(1)))
gray = gray[int(top.y - eye.distance(eyebrow) / 2):int(top.y + top.distance(bottom)),
int(left.x):int(left.x + left.distance(right))]
#ujednacavanje histograma
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
gray = clahe.apply(gray)
#gray = cv2.bilateralFilter(gray, 9, 75, 75)
ratio = 300.0 / gray.shape[1]
dimensions = (300, int(gray.shape[0] * ratio))
gray = cv2.resize(gray, dimensions, interpolation=cv2.INTER_AREA)
cv2.imwrite("Camera/Resources/" + str(i) + '.png', gray)
for i in range(0, 7):
self.statusLabel.set_text("Slanje uzoraka")
client.send("ftp:" + str(i))
self.waitForResponse()
imageFile = open("Camera/Resources/" + str(i) + '.png', "rb")
offset = 0
while True:
sent = sendfile(client.fileno(), imageFile.fileno(), offset, 4096)
if sent == 0:
client.send("EOF")
break # EOF
offset += sent
self.statusLabel.set_text("Potvrdite PIN")
self.btnConfirm.set_sensitive(True)
self.waitForResponse()
