def main():
from cpld import Platform
from stabilizer import Stabilizer
p = Platform()
s = Stabilizer(p)
p.build(s, build_name="stabilizer", mode="cpld")
def init_model(transform):
global mark_detector, box_process, img_queue, box_queue, pose_estimator, pose_stabilizers, tm
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
# img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
tm = cv2.TickMeter()
return None, None
class TestStabilizer(unittest.TestCase):
def setUp(self):
originalVideo = Video('/home/victorhugomoura/Documents/example.mp4')
acceleratedVideo = Video(
'/home/victorhugomoura/Documents/Folder With Spaces/example.avi')
velocity = 10
self.stabilizer = Stabilizer(originalVideo, acceleratedVideo, velocity)
def testCorrectPath(self):
original = self.stabilizer.originalVideo.file()
expected = '"/home/victorhugomoura/Documents/example.mp4"'
self.assertEqual(self.stabilizer.correctPath(original), expected)
original = self.stabilizer.acceleratedVideo.file()
expected = '"/home/victorhugomoura/Documents/Folder With Spaces/example.avi"'
self.assertEqual(self.stabilizer.correctPath(original), expected)
def gen3(camera):
"""Video streaming generator function."""
mark_detector = None
flag1 = True
if mark_detector == None:
mark_detector = MarkDetector()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
# height, width = sample_frame.shape[:2]
# pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
while True:
frame, flag1 = camera.get_frame3(mark_detector, pose_stabilizers,
flag1)
# print (frame)
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
def __init__(self,
frame,
EYE_AR_THRESH=0.3,
ROLL_THRESH=20,
TIME_THRESH=10):
self.EYE_AR_THRESH = EYE_AR_THRESH
self.ROLL_THRESH = ROLL_THRESH
self.TIME_THRESH = TIME_THRESH
self.ALARM_ON = False
self.T = None
self.faceDetector = FaceDetector()
self.eyeDetector = EyeDetector()
self.markDetector = MarkDetector(self.faceDetector)
# Setup process and queues for multiprocessing.
self.img_queue = Queue()
self.box_queue = Queue()
self.img_queue.put(frame)
self.box_process = Process(target=self.get_face,
args=(self.markDetector, ))
self.box_process.start()
h, w = frame.shape[:2]
self.poseEstimator = PoseEstimator(img_size=(h, w))
self.pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
class TestStabilizer(unittest.TestCase):
def setUp(self):
originalVideo = Video('/home/victorhugomoura/Documents/example.mp4')
acceleratedVideo = Video(
'/home/victorhugomoura/Documents/out/example.mp4')
self.stabilizer = Stabilizer(originalVideo, acceleratedVideo, '10')
def testCheckParameters(self):
self.stabilizer.checkParameters()
self.stabilizer.originalVideo = Video(
'/home/victorhugomoura/Documents/example.csv')
self.assertRaises(InputError, self.stabilizer.checkParameters)
self.setUp()
self.stabilizer.acceleratedVideo = Video(
'/home/victorhugomoura/Documents/out/example.csv')
self.assertRaises(InputError, self.stabilizer.checkParameters)
self.setUp()
self.stabilizer.velocity = '1'
self.assertRaises(InputError, self.stabilizer.checkParameters)
def __init__(self):
print "OpenCV version: {}".format(cv2.__version__)
self.CNN_INPUT_SIZE = 128
self.mark_detector = MarkDetector()
height = 480
width = 640
self.pose_estimator = PoseEstimator(img_size=(height, width))
self.pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(8)
]
self.img_queue = Queue()
self.box_queue = Queue()
self.box_process = Process(target=self.get_face,
args=(
self.mark_detector,
self.img_queue,
self.box_queue,
))
self.process_ctrl_flag = rospy.get_param("process_ctrl", True)
self.process_ctrl_subscriber = rospy.Subscriber(
"/head_pose_estimator/process_ctrl", Bool,
self.process_ctrl_callback)
self.sub_img_name = rospy.get_param("sub_img_name",
"/usb_cam/image_raw")
self.img_subscriber = rospy.Subscriber(self.sub_img_name, Image,
self.img_callback)
self.show_result_img_flag = rospy.get_param("show_result_img", True)
self.show_axis_flag = rospy.get_param("show_axis", True)
self.show_annotation_box_flag = rospy.get_param(
"show_annotation_box", True)
self.pub_result_img_flag = rospy.get_param("pub_result_img", True)
self.img_publisher = rospy.Publisher(
"/head_pose_estimator/result_image", Image, queue_size=10)
self.result_publisher = rospy.Publisher(
"/head_pose_estimator/head_pose", HeadPose, queue_size=10)
self.box_process.start()
def main():
p = Platform()
dut = Stabilizer(p)
tb = TB(p, dut)
run_simulation(tb, [tb.test()],
vcd_name="stabilizer.vcd",
clocks={
"sys": 8,
"sck1": 8,
"sck0": 8,
"le": 8
},
special_overrides={
Tristate: SimTristate,
Instance: SimInstance
})
def __init__(self):
# Load the parameters
self.conf = config()
# initialize dlib's face detector (HOG-based) and then create the
# facial landmark predictor
print("[INFO] loading facial landmark predictor...")
self.detector = dlib.get_frontal_face_detector()
self.predictor = dlib.shape_predictor(self.conf.shape_predictor_path)
# grab the indexes of the facial landmarks for the left and
# right eye, respectively
(self.lStart, self.lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(self.rStart, self.rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
# initialize the video stream and sleep for a bit, allowing the
# camera sensor to warm up
self.cap = cv2.VideoCapture(0)
if self.conf.vedio_path == 0:
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sample_frame = self.cap.read()
# Introduce mark_detector to detect landmarks.
self.mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
self.img_queue = Queue()
self.box_queue = Queue()
self.img_queue.put(sample_frame)
self.box_process = Process(target=get_face, args=(
self.mark_detector, self.img_queue, self.box_queue,))
self.box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
self.height, self.width = sample_frame.shape[:2]
self.pose_estimator = PoseEstimator(img_size=(self.height, self.width))
# Introduce scalar stabilizers for pose.
self.pose_stabilizers = [Stabilizer(
state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)]
self.tm = cv2.TickMeter()
# Gaze tracking
self.gaze = GazeTracking()
def init():
"""MAIN"""
# Video source from webcam or video file.
video_src = args.cam if args.cam is not None else args.video
if video_src is None:
print(
"Warning: video source not assigned, default webcam will be used.")
video_src = 0
cap = cv2.VideoCapture(video_src)
if video_src == 0:
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sample_frame = cap.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
tm = cv2.TickMeter()
return cap, video_src, img_queue, box_queue, tm, mark_detector, pose_estimator
def init(self):
self.detector = RetinaFace('./model/R50', 0, 0, 'net3')
self.mark_detector = MarkDetector()
self.pose_stabilizers = [Stabilizer(
state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)]
sample_img = None
#if self.color_img is None:
# print("None")
# time.sleep(0.2)
#
#height, width, _ = self.color_img.shape
self.pose_estimator = PoseEstimator(img_size=(480, 640))
def Camera_Capture():
mark_detector = MarkDetector()
name = input("Enter student id:")
directory = os.path.join(facepath, name)
if not os.path.exists(facepath):
os.makedirs(facepath, exist_ok = 'True')
if not os.path.exists(directory):
try:
os.makedirs(directory, exist_ok = 'True')
except OSError as e:
if e.errno != errno.EEXIST:
print('invalid student id or access denied')
return
poses=['frontal','right','left','up','down']
file=0
cap = cv2.VideoCapture(file)
ret, sample_frame = cap.read()
i = 0
count = 0
if ret==False:
return
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [Stabilizer(
state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)]
images_saved_per_pose=0
number_of_images = 0
shape_predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
face_aligner = FaceAligner(shape_predictor, desiredFaceWidth=FACE_WIDTH)
while i<5:
saveit = False
# Read frame, crop it, flip it, suits your needs.
ret, frame = cap.read()
if ret is False:
break
if count % 5 !=0: # skip 5 frames
count+=1
continue
if images_saved_per_pose==IMAGE_PER_POSE:
i+=1
images_saved_per_pose=0
# If frame comes from webcam, flip it so it looks like a mirror.
if file == 0:
frame = cv2.flip(frame, 2)
original_frame=frame.copy()
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
facebox = mark_detector.extract_cnn_facebox(frame)
if facebox is not None:
# Detect landmarks from image of 128x128.
x1=max(facebox[0]-0,0)
x2=min(facebox[2]+0,width)
y1=max(facebox[1]-0,0)
y2=min(facebox[3]+0,height)
face = frame[y1: y2,x1:x2]
face_img = cv2.resize(face, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
marks = mark_detector.detect_marks([face_img])
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
steady_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
steady_pose.append(ps_stb.state[0])
steady_pose = np.reshape(steady_pose, (-1, 3))
# print(steady_pose[0][0])
# if steady_pose[0][0]>0.1:
# print('right')
# else:
# if steady_pose[0][0]<-0.1:
# print('left')
# if steady_pose[0][1]>0.1:
# print('down')
# else:
# if steady_pose[0][1]<-0.1:
# print('up')
# print(steady_pose[0])
if i==0:
if abs(steady_pose[0][0])<ANGLE_THRESHOLD and abs(steady_pose[0][1])<ANGLE_THRESHOLD:
images_saved_per_pose+=1
saveit = True
if i==1:
if steady_pose[0][0]>ANGLE_THRESHOLD:
images_saved_per_pose+=1
saveit = True
if i==2:
if steady_pose[0][0]<-ANGLE_THRESHOLD:
images_saved_per_pose+=1
saveit = True
if i==3:
if steady_pose[0][1]<-ANGLE_THRESHOLD:
images_saved_per_pose+=1
saveit = True
if i==4:
if steady_pose[0][1]>ANGLE_THRESHOLD:
images_saved_per_pose+=1
saveit = True
# Show preview.
if i>=5:
print ('Thank you')
break
frame = cv2.putText(frame,poses[i] +' : '+ str(images_saved_per_pose)+'/'+str(IMAGE_PER_POSE),(10,50),cv2.FONT_HERSHEY_SIMPLEX,2,(255,255,255),1,cv2.LINE_AA)
frame = cv2.rectangle(frame, (x1,y1), (x2,y2),(255,255,0),2)
cv2.imshow("Preview", frame)
if saveit:
face = dlib.rectangle(x1, y1, x2, y2)
face_aligned = face_aligner.align(original_frame, frame_gray, face)
cv2.imwrite(os.path.join(directory, str(name)+'_'+str(number_of_images)+'.jpg'), face_aligned)
print(images_saved_per_pose)
number_of_images+=1
if cv2.waitKey(10) == 27:
break
cap.release()
cv2.destroyAllWindows()
def stabilizePart(self, acceleratedVideo, writeFunction):
stabilizer = Stabilizer(self.video, acceleratedVideo, self.velocity)
stabilizer.run(writeFunction)
os.chdir(self.path)
def main():
instructions = 0
print "--- Intention classification for communication between a human and a robot ---"
if instructions == 1:
print "First you will be required to present a facial expression before you will do a head movement."
print "If done correctly these gestures will be detected by the robot and it will perform the desired task."
raw_input("Press Enter to continue...")
if instructions == 1:
print "This is the module for facial expression recognition."
print "This program can detect the emotions: Happy and Angry."
print "The program will look for the expression for 3 seconds."
raw_input("To proceed to Facial Expression Recognition press Enter...")
predictExp = 0
# Load Facial Expression Recognition trained model
print "- Loading FER model... -"
#faceExpModel = tf.keras.models.load_model("/home/bjornar/ML_models/FER/Good models(80+)/tf_keras_weights_ninthRev-88percent/tf_keras_weights_ninthRev.hdf5")
faceExpModel = tf.keras.models.load_model(
"/home/project/Bjorn/tf_keras_weights_ninthRev-88percent/tf_keras_weights_ninthRev.hdf5"
)
# Load Face Cascade for Face Detection
print "- Loading Face Cascade for Face Detection... -"
#cascPath = "/home/bjornar/MScDissertation/TrainingData/FaceDetection/haarcascade_frontalface_default.xml"
cascPath = "/home/project/Bjorn/IntentionClassification-Repository/haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascPath)
## Initializing Head Movement variables
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
sample_frame = cv2.imread("sample_frame.png")
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
noseMarks = [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0],
[0, 0], [0, 0], [0, 0]]
counter = 0
font = cv2.FONT_HERSHEY_SIMPLEX
numXPoints = 0
numYPoints = 0
sumX = 0
sumY = 0
currentTime = 0
previousTime1 = 0
previousTime2 = 0
directionArray = []
moveSequence = []
moves = []
classifyMoves = 0
headPoseDirection = 'emtpy'
if camera == 'kinect':
## Initialize Kinect camera
print "Initializing camera..."
try:
from pylibfreenect2 import OpenGLPacketPipeline
pipeline = OpenGLPacketPipeline()
except:
try:
from pylibfreenect2 import OpenCLPacketPipeline
pipeline = OpenCLPacketPipeline()
except:
from pylibfreenect2 import CpuPacketPipeline
pipeline = CpuPacketPipeline()
#print("Packet pipeline:", type(pipeline).__name__)
# Create and set logger
#logger = createConsoleLogger(LoggerLevel.Debug)
setGlobalLogger()
fn = Freenect2()
num_devices = fn.enumerateDevices()
if num_devices == 0:
print("- No device connected! -")
sys.exit(1)
serial = fn.getDeviceSerialNumber(0)
device = fn.openDevice(serial, pipeline=pipeline)
listener = SyncMultiFrameListener(FrameType.Color | FrameType.Ir
| FrameType.Depth)
# Register listeners
device.setColorFrameListener(listener)
device.setIrAndDepthFrameListener(listener)
device.start()
# NOTE: must be called after device.start()
registration = Registration(device.getIrCameraParams(),
device.getColorCameraParams())
elif camera == 'webcam':
#video_capture = cv2.VideoCapture(0)
video_capture = cv2.VideoCapture(-1)
elif camera == 'video':
#video_capture = cv2.VideoCapture(0)
video_capture = cv2.VideoCapture(
"/home/project/Bjorn/SonyHandycamTest.mp4")
## Facial Expression Recognition variables
FER_prediction = []
FERclass = ''
FERstart = 0
classifyMoves = 0
## Head movement variables
predictHeadMov = 3
HeadMov = []
HMCclass = ''
detectedFaces = []
mark = []
notDone = 0
progressStatus = [0, 0]
while notDone in progressStatus: # This waits for each module to finsih
if camera == 'kinect':
frames = listener.waitForNewFrame()
color = frames["color"]
color = color.asarray()
color = cv2.resize(color, (int(873), int(491)))
color = color[0:480, 150:790]
color = np.delete(color, np.s_[3::], 2)
elif camera == 'webcam':
# Capture frame-by-frame
ret, color = video_capture.read()
elif camera == 'video':
# Capture frame-by-frame
ret, color = video_capture.read()
## Detect facial expression
predictExpNums = [1, 2]
if predictExp == 0:
while predictExp not in predictExpNums:
predictExp = int(
raw_input(
"\nPress 1 to detect Facial Expression or press 2 to do Head Movement classification."
))
if predictExp == 1:
predictExp = 1
print "------ Facial Expression Recognition ------"
elif predictExp == 2:
predictHeadMov = 0
progressStatus[0] = 1
FERstart = time.time()
elif predictExp == 1:
currentTime = time.time()
if currentTime - FERstart < 10:
FER_prediction.append(
facialExpressionRecogntion(color, faceExpModel,
faceCascade))
else:
predictExp = 2
FER_prediction = filter(None, FER_prediction)
FERclass = mostCommon(FER_prediction)
FERclass = FERclass[2:7]
predictHeadMov = 0
if FERclass == '':
print("Did not detect an expression, try again.")
predictExp = 0
else:
progressStatus[0] = 1
print "Detected expression: " + str(FERclass)
print "Progress: FER DONE"
# else:
# #cv2.imwrite("sample_frame.png", color)
# break
## Detect head movement class
if predictHeadMov == 0:
predictHeadMov = int(
raw_input(
"\nPress 1 to do Head Movement classification or 2 to skip."
))
if predictHeadMov == 1:
predictHeadMov = 1
print "------ Head Movement Classification ------"
moveTime = int(
raw_input(
"How many seconds should I record your movement?"))
#moveTime = 2
else:
predictHeadMov = 2
timer = time.time()
previousTime1 = timer
previousTime2 = timer
if predictHeadMov == 1:
print color.shape
color = color[0:480, 0:480]
color = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY)
cv2.imshow("", color)
raw_input()
print color.shape
# Feed frame to image queue.
img_queue.put(color)
#pdb.set_trace()
# Get face from box queue.
facebox = box_queue.get()
print color.shape
if facebox is not None:
# Detect landmarks from image of 128x128.
face_img = color[facebox[1]:facebox[3], facebox[0]:facebox[2]]
face_img = cv2.resize(face_img,
(CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
marks = mark_detector.detect_marks(face_img)
#Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(color, headPoseDirection, (20, 70), font, 1,
(0, 255, 0), 4)
# # Get average position of nose
noseMarksTemp = []
noseMarksTemp.append(marks[30][0])
noseMarksTemp.append(marks[30][1])
noseMarks[0] = noseMarksTemp
for i in range(9, 0, -1):
noseMarks[i] = noseMarks[i - 1]
# Get the direction of head movement
headPoseDirection = calculateDirection(noseMarks)
directionArray.append(headPoseDirection)
if classifyMoves == 0:
classifyMoves = 1
timer = time.time()
previousTime1 = timer
previousTime2 = timer
currentTime = time.time()
if currentTime - previousTime1 > moveTime and classifyMoves == 1:
print "------------------------------------------------"
print "Elapsed timer 1: " + str(currentTime -
previousTime1)
# Get most common direction
HMCclass = mostCommon(directionArray)
classifyMoves = 2
directionArray = []
previousTime1 = currentTime
progressStatus[1] = 1
print "Progress: HMC DONE"
else:
print "Did not detect a face"
elif predictHeadMov == 2:
progressStatus[1] = 1
print "Skipped Head Movement Estimation."
break
# if notDone in progressStatus and predictHeadMov == 2 and predictExp == 2:
# print "You seem to have skipped one or more tasks."
# inpt = ''
# while inpt == '':
# inpt = raw_input("To do FER press 1 and to do HMC press 2...")
# if input == '1':
# predictExp = 1
# elif input == '2':
# predictHeadMov
cv2.imshow("", color)
if camera == 'kinect':
listener.release(frames)
key = cv2.waitKey(delay=1)
if key == ord('q'):
break
if camera == 'kinect':
listener.release(frames)
device.stop()
device.close()
elif camera == 'webcam' or camera == 'video':
video_capture.release()
cv2.destroyAllWindows()
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()
print "---------------- RESULT ----------------"
if FERclass != '':
print "Detected facial expression: " + str(FERclass)
else:
print "Did not detect any expression."
if HMCclass != '':
print "Detected head movement: " + str(HMCclass)
else:
print "Did not detect a head movement."
print "----------------------------------------"
intentionClassification = [FERclass, HMCclass]
return intentionClassification
def main():
#bagreader = BagFileReader(args.video, 640,480,848,480,30,30)
bagreader = BagFileReader(args.video, 640, 480, 640, 480, 15, 15)
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
sample_frame = bagreader.get_color_frame()
sample_frame = cv2.cvtColor(sample_frame, cv2.COLOR_BGR2RGB)
height, width, _ = sample_frame.shape
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
out = cv2.VideoWriter('output-%s.avi' % args.name_output, fourcc, args.fps,
(width, height))
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
tm = cv2.TickMeter()
while True:
t1 = time.time()
# Read frame, crop it, flip it, suits your needs.
frame = bagreader.get_color_frame()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
if frame is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
# if video_src == 0:
# frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
faceboxes = box_queue.get()
print(faceboxes)
mess = "Not detect pose"
if faceboxes is not None:
if isinstance(faceboxes[1], int):
faceboxes = [faceboxes]
for facebox in faceboxes:
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]:facebox[3], facebox[0]:facebox[2]]
face_img = cv2.resize(face_img,
(CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
tm.start()
marks = mark_detector.detect_marks([face_img])
tm.stop()
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Uncomment following line to show raw marks.
# mark_detector.draw_marks(
# frame, marks, color=(0, 255, 0))
# Uncomment following line to show facebox.
# mark_detector.draw_box(frame, [facebox])
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
steady_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
steady_pose.append(ps_stb.state[0])
steady_pose = np.reshape(steady_pose, (-1, 3))
# Uncomment following line to draw pose annotation on frame.
pose_estimator.draw_annotation_box(frame,
pose[0],
pose[1],
color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotation on frame.
t2 = time.time()
mess = round(1 / (t2 - t1), 2)
# pose_estimator.draw_annotation_box(
# frame, steady_pose[0], steady_pose[1], color=(128, 255, 128))
# Uncomment following line to draw head axes on frame.
# pose_estimator.draw_axes(frame, stabile_pose[0], stabile_pose[1])
cv2.putText(frame,
"FPS: " + "{}".format(mess), (20, 20),
cv2.FONT_HERSHEY_SIMPLEX,
0.75, (0, 255, 0),
thickness=2)
# Show preview.
cv2.imshow("Preview", frame)
out.write(frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
out.release()
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()
def run():
# Load the parameters
conf = config()
# 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(conf.shape_predictor_path)
# 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"]
# initialize the video stream and sleep for a bit, allowing the
# camera sensor to warm up
# cap = cv2.VideoCapture(conf.vedio_path)
cap = cv2.VideoCapture(0)
if conf.vedio_path == 0:
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sample_frame = cap.read()
# sample_frame = imutils.rotate(sample_frame, 90)
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
tm = cv2.TickMeter()
# Gaze tracking
gaze = GazeTracking()
# loop over the frames from the video stream
temp_steady_pose = 0
while True:
# grab the frame from the threaded video stream, resize it to
# have a maximum width of 400 pixels, and convert it to
# grayscale
frame_got, frame = cap.read()
# Empty frame
frame_empty = np.zeros(frame.shape)
# frame = imutils.rotate(frame, 90)
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
rects = detector(gray, 0)
# check to see if a face was detected, and if so, draw the total
# number of faces on the frame
if len(rects) > 0:
text = "{} face(s) found".format(len(rects))
# cv2.putText(frame, text, (30, 30), cv2.FONT_HERSHEY_SIMPLEX,
# 0.5, (0, 0, 255), 2)
# Empty frame
cv2.putText(frame_empty, text, (30, 30), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 0, 255), 2)
# initialize the frame counters and the total number of blinks
TOTAL = 0
COUNTER = 0
# loop over the face detections
for (i, rect) in enumerate(rects):
# determine the facial landmarks for the face region, then
# convert the facial landmark (x, y)-coordinates to a NumPy
# array
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
# ********************************
# Blink detection
# 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)
# Frame empty
cv2.drawContours(frame_empty, [leftEyeHull], -1, (0, 255, 0), 1)
cv2.drawContours(frame_empty, [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 < conf.EYE_AR_THRESH:
COUNTER += 1
# otherwise, the eye aspect ratio is not below the blink
# threshold
else:
# if the eyes were closed for a sufficient number of
# then increment the total number of blinks
if COUNTER >= conf.EYE_AR_CONSEC_FRAMES:
TOTAL += 1
# reset the eye frame counter
COUNTER = 0
# draw the total number of blinks on the frame along with
# the computed eye aspect ratio for the frame
# cv2.putText(frame, "Blinks: {}".format(TOTAL), (30, 60),
# cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# cv2.putText(frame, "EAR: {:.2f}".format(ear), (30, 90),
# cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# Frame empty
cv2.putText(frame_empty, "Blinks: {}".format(TOTAL), (30, 60),
cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 255), 2)
cv2.putText(frame_empty, "EAR: {:.2f}".format(ear), (30, 90),
cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 255), 2)
# ********************************
# convert dlib's rectangle to a OpenCV-style bounding box
# [i.e., (x, y, w, h)], then draw the face bounding box
(x, y, w, h) = face_utils.rect_to_bb(rect)
# cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
#
# show the face number
# cv2.putText(frame, "Face #{}".format(i + 1), (30, 120),
# cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
# Frame empty
cv2.rectangle(frame_empty, (x, y), (x + w, y + h), (0, 255, 0), 2)
# show the face number
cv2.putText(frame_empty, "Face #{}".format(i + 1), (30, 120),
cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 255), 2)
# loop over the (x, y)-coordinates for the facial landmarks
# and draw them on the image
for (x, y) in shape:
# cv2.circle(frame, (x, y), 1, (0, 255, 255), -1)
cv2.circle(frame_empty, (x, y), 1, (0, 255, 255), -1)
# **********************************************************
if frame_got is False:
break
# If frame comes from webcam, flip it so it looks like a mirror.
if conf.vedio_path == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
facebox = box_queue.get()
if facebox is not None:
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]:facebox[3], facebox[0]:facebox[2]]
face_img = cv2.resize(face_img,
(conf.CNN_INPUT_SIZE, conf.CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
tm.start()
marks = mark_detector.detect_marks([face_img])
tm.stop()
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Uncomment following line to show raw marks.
# mark_detector.draw_marks(
# frame, marks, color=(0, 255, 0))
# Uncomment following line to show facebox.
# mark_detector.draw_box(frame, [facebox])
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
steady_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
steady_pose.append(ps_stb.state[0])
steady_pose = np.reshape(steady_pose, (-1, 3))
# Uncomment following line to draw pose annotation on frame.
# pose_estimator.draw_annotation_box(
# frame, pose[0], pose[1], color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotation on frame.
# pose_estimator.draw_annotation_box(frame, steady_pose[0], steady_pose[1], color=(128, 255, 128))
# Uncomment following line to draw head axes on frame.
# pose_estimator.draw_axes(frame, steady_pose[0], steady_pose[1])
pose_estimator.draw_axes(frame_empty, steady_pose[0],
steady_pose[1])
print('steady pose vector: {}'.format(steady_pose[0],
steady_pose[1]))
else:
# cv2.putText(frame, "Signal loss", (200, 200),
# cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(frame_empty, "Signal loss", (200, 200),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
# ******************************************************************
# We send this frame to GazeTracking to analyze it
gaze.refresh(frame)
frame = gaze.annotated_frame()
text = ""
if gaze.is_blinking():
text = "Blinking"
elif gaze.is_right():
text = "Looking right"
elif gaze.is_left():
text = "Looking left"
elif gaze.is_center():
text = "Looking center"
cv2.putText(frame_empty, text, (250, 250), cv2.FONT_HERSHEY_DUPLEX,
0.5, (147, 58, 31), 2)
left_pupil = gaze.pupil_left_coords()
right_pupil = gaze.pupil_right_coords()
cv2.putText(frame_empty, "Left pupil: " + str(left_pupil), (250, 280),
cv2.FONT_HERSHEY_DUPLEX, 0.5, (147, 58, 31), 1)
cv2.putText(frame_empty, "Right pupil: " + str(right_pupil),
(250, 310), cv2.FONT_HERSHEY_DUPLEX, 0.5, (147, 58, 31), 1)
# ********************************************************************
# show the frame
# cv2.imshow("Frame", frame)
cv2.imshow("Frame", frame_empty)
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()
cap.stop()
box_queue = Queue()
img_queue.put(sample_frame)
thread = threading.Thread(target=get_face,
args=(mark_detector, img_queue, box_queue))
thread.daemon = True
thread.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
tm = cv2.TickMeter()
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cap.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
def __init__(self):
""" Subscribers """
rospy.Subscriber("/camera/depth/image_rect_raw",
Image,
self.callback_depth,
queue_size=1)
rospy.Subscriber("/camera/infra1/image_rect_raw",
Image,
self.callback_infra,
queue_size=1)
rospy.Subscriber("/flag_pub",
Float32,
self.callback_flag,
queue_size=1)
""" Publishers """
self.img_bag_pub = rospy.Publisher("Image_bag", Image, queue_size=1)
self.info = rospy.Publisher("driver_info", driver_info, queue_size=1)
self.msg_driver = driver_info()
self.quaternion = rospy.Publisher("quaternion",
PoseStamped,
queue_size=1)
self.q = PoseStamped()
self.q.header.frame_id = "map"
self.heart_rate_b = rospy.Publisher("heart_rate_b",
Float32,
queue_size=1)
self.heart_rate_b_msg = Float32()
""" Node Parameters """
self.cont_video = 0
self.data_buffernose_gray = [0] * 200
self.data_bufferforehead_gray = [0] * 200
self.matrix_v = [0]
self.nose_ica_g = [0]
self.fore_ica_g = [0]
self.time_v = []
self.detector = dlib.get_frontal_face_detector()
self.predictor = dlib.shape_predictor(
os.path.join(os.path.dirname(sys.path[0]), 'scripts',
'shape_predictor_68_face_landmarks.dat'))
self.model68 = (os.path.join(os.path.dirname(sys.path[0]), 'scripts',
'model.txt'))
self.bpm_a = 0
self.bpm_a_b = 0
self.window_hr = 0
self.yawn_state = False
self.window_hr_b = 0
self.pulso_pantalla = 0
self.pulso_guardado = 0
self.pulso_adquirido = 0
self.pulso_pantalla_b = 0
self.pulso_guardado_b = 0
self.pulso_adquirido_b = 0
self.pitch_counter = 0
self.cont_state = 0
self.cont = 0
self.cont2 = 0
self.yaw_counter = 0
self.cont_yawn = 0
self.yawn_counter = 0
self.flag = 0
self.flag_300 = 0
self.eye_thresh = 0.3
self.mouth_thresh = 0.60
self.num_frames = 2
self.blink_counter = 0
self.total = 0
self.eyes_open = 0.0
self.eyes_closed = 0.0
self.perclos = 0.0
self.mouth_status = False
#self.current_depth = []
#cv2.namedWindow('frame')
#self.img_publisher = rospy.Publisher("topico_imagen", Image)
"""Parameters for head pose estimation"""
self.model_points_68 = self._get_full_model_points()
self.size = (480, 640)
self.focal_length = self.size[1]
self.camera_center = (self.size[1] / 2, self.size[0] / 2)
self.camera_matrix = np.array(
[[self.focal_length, 0, self.camera_center[0]],
[0, self.focal_length, self.camera_center[1]], [0, 0, 1]],
dtype="double")
self.dist_coeefs = np.zeros((4, 1))
self.r_vec = np.array([[0.01891013], [0.08560084], [-3.14392813]])
self.t_vec = np.array([[-14.97821226], [-10.62040383],
[-2053.03596872]])
self.pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
"""Graph Parameters"""
cv.LINE_AA)
cv.line(image, tuple(point_2d[3]), tuple(point_2d[8]), color, line_width,
cv.LINE_AA)
return image
def eye_aspect_ratio(eye):
A = dist.euclidean(eye[1], eye[5])
B = dist.euclidean(eye[2], eye[4])
C = dist.euclidean(eye[0], eye[3])
EAR = (A + B) / (2.0 * C)
return EAR
pose_stabilizers = [
Stabilizer(state_num=2, measure_num=1, cov_process=0.1, cov_measure=0.1)
for _ in range(6)
]
face_detector = dlib.get_frontal_face_detector()
head_landmard_detector = dlib.shape_predictor(
'shape_predictor_68_face_landmarks.dat')
#3D model for human facial landamrk
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
def setUp(self):
originalVideo = Video('/home/victorhugomoura/Documents/example.mp4')
acceleratedVideo = Video(
'/home/victorhugomoura/Documents/Folder With Spaces/example.avi')
velocity = 10
self.stabilizer = Stabilizer(originalVideo, acceleratedVideo, velocity)
def main(video_src):
"""MAIN
:param video_src: Source of video to analyze
:type video_src: str or int"""
cam = cv2.VideoCapture(video_src)
_, sample_frame = cam.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
face_detector = FaceDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face, args=(mark_detector, img_queue, box_queue,))
#box_process = Process(target=get_faces, args=(face_detector, img_queue, box_queue,))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [Stabilizer(
state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)]
#face expression recognizer initialization
from keras.models import model_from_json
model = model_from_json(open("./model/facial_expression_model_structure.json", "r").read())
model.load_weights('./model/facial_expression_model_weights.h5') #load weights
#-----------------------------
emotions = ('angry', 'disgust', 'fear', 'happy', 'sad', 'surprise', 'neutral')
while True:
input()
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cam.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
if video_src == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
#facebox = box_queue.get()
faceboxes = dump_queue(box_queue)
print("{} FACEBOXES".format(len(faceboxes)))
for facebox in faceboxes:
if min(facebox) < 0:
continue
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]: facebox[3],
facebox[0]: facebox[2]]
if not face_img.shape[0] or not face_img.shape[1]:
continue
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
marks = mark_detector.detect_marks(face_img)
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Uncomment following line to show raw marks.
# mark_detector.draw_marks(
# frame, marks, color=(0, 255, 0))
detected_face = frame[facebox[1]: facebox[3],facebox[0]: facebox[2]] #crop detected face
detected_face = cv2.cvtColor(detected_face, cv2.COLOR_BGR2GRAY) #transform to gray scale
detected_face = cv2.resize(detected_face, (48, 48)) #resize to 48x48
# emotion estimation
img_pixels = image.img_to_array(detected_face)
img_pixels = np.expand_dims(img_pixels, axis = 0)
img_pixels /= 255 #pixels are in scale of [0, 255]. normalize all pixels in scale of [0, 1]
predictions = model.predict(img_pixels) #store probabilities of 7 expressions
#find max indexed array 0: angry, 1:disgust, 2:fear, 3:happy, 4:sad, 5:surprise, 6:neutral
max_index = np.argmax(predictions[0])
emotion = emotions[max_index]
#write emotion text above rectangle
#V_FONT_HERSHEY_SIMPLEX normal size sans-serif font
#CV_FONT_HERSHEY_PLAIN small size sans-serif font
#CV_FONT_HERSHEY_DUPLEX normal size sans-serif font (more complex than CV_FONT_HERSHEY_SIMPLEX )
#CV_FONT_HERSHEY_COMPLEX normal size serif font
#CV_FONT_HERSHEY_TRIPLEX normal size serif font (more complex than CV_FONT_HERSHEY_COMPLEX )
#CV_FONT_HERSHEY_COMPLEX_SMALL smaller version of CV_FONT_HERSHEY_COMPLEX
#CV_FONT_HERSHEY_SCRIPT_SIMPLEX hand-writing style font
#CV_FONT_HERSHEY_SCRIPT_COMPLEX more complex variant of CV_FONT_HERSHEY_SCRIPT_SIMPLEX
image_text = ""
for index in range(len(emotions)):
if predictions[0][index]>0.3:
image_text += "{0} : {1} %\n".format(emotions[index], int(predictions[0][index]*100))
space = 0
for text in image_text.strip().split("\n"):
cv2.putText(
img = frame,
text= text,
org =(int(facebox[0]), int(facebox[1])-space),
fontFace = cv2.FONT_HERSHEY_PLAIN,
fontScale = 0.8,
color = (255,255,255),
thickness = 1
)
space += int(0.25*48)
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
#pose = pose_estimator.solve_pose(marks)
# Stabilize the pose.
#stabile_pose = []
#pose_np = np.array(pose).flatten()
#for value, ps_stb in zip(pose_np, pose_stabilizers):
# ps_stb.update([value])
# stabile_pose.append(ps_stb.state[0])
#stabile_pose = np.reshape(stabile_pose, (-1, 3))
# Uncomment following line to draw pose annotaion on frame.
pose_estimator.draw_annotation_box(
frame, pose[0], pose[1], color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotaion on frame.
#pose_estimator.draw_annotation_box(
# frame, stabile_pose[0], stabile_pose[1], color=(128, 255, 128))
# Show preview.
cv2.imshow("Preview", frame)
if cv2.waitKey(10) == 27:
break
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()
def main():
"""MAIN"""
# video source from webcam or video file
videoSource = args.cam if args.cam is not None else args.video
if videoSource is None:
print(
"Warning: video source not assigned, default webcam will be used.")
videoSource = 0
cap = cv2.VideoCapture(videoSource)
if videoSource == 0:
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sampleFrame = cap.read()
# introduce markDetector to detect landmarks
markDetector = MarkDetector()
# setup process and queues for multiprocessing
imgQueue = Queue()
boxQueue = Queue()
imgQueue.put(sampleFrame)
boxProcess = Process(target=getFace,
args=(
markDetector,
imgQueue,
boxQueue,
))
boxProcess.start()
# introduce pose estimator to solve pose
# get one frame to setup the estimator according to the image size
height, width = sampleFrame.shape[:2]
poseEstimator = PoseEstimator(imgSize=(height, width))
# introduce scalar stabilizers for pose
poseStabilizers = [
Stabilizer(stateNum=2, measureNum=1, covProcess=0.1, covMeasure=0.1)
for _ in range(6)
]
tm = cv2.TickMeter()
while True:
# read frame, crop it, flip it, suits your needs
frameGot, frame = cap.read()
if frameGot is False:
break
# crop it if frame is larger than expected
# frame = frame[0:480, 300:940]
# if frame comes from webcam, flip it so it looks like a mirror
if videoSource == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face
# 2. detect landmarks
# 3. estimate pose
# feed frame to image queue
imgQueue.put(frame)
# get face from box queue
facebox = boxQueue.get()
if facebox is not None:
# detect landmarks from image of 128x128
faceImg = frame[facebox[1]:facebox[3], facebox[0]:facebox[2]]
faceImg = cv2.resize(faceImg, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
faceImg = cv2.cvtColor(faceImg, cv2.COLOR_BGR2RGB)
tm.start()
marks = markDetector.detectMarks([faceImg])
tm.stop()
# convert the marks locations from local CNN to global image
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# uncomment following line to show raw marks
# markDetector.drawMarks(frame, marks, color=(0, 255, 0))
# uncomment following line to show facebox
# markDetector.drawBox(frame, [facebox])
# try pose estimation with 68 points
pose = poseEstimator.solvePoseBy68Points(marks)
# stabilize the pose
steadyPose = []
poseNp = np.array(pose).flatten()
for value, psStb in zip(poseNp, poseStabilizers):
psStb.update([value])
steadyPose.append(psStb.state[0])
steadyPose = np.reshape(steadyPose, (-1, 3))
# uncomment following line to draw pose annotation on frame
# poseEstimator.drawAnnotationBox(frame, pose[0], pose[1], color=(255, 128, 128))
# uncomment following line to draw stabile pose annotation on frame
poseEstimator.drawAnnotationBox(frame,
steadyPose[0],
steadyPose[1],
color=(128, 255, 128))
# uncomment following line to draw head axes on frame
# poseEstimator.drawAxes(frame, stabile_pose[0], stabile_pose[1])
# Show preview.
cv2.imshow("Preview", frame)
if cv2.waitKey(10) == 27:
break
# Clean up the multiprocessing process.
boxProcess.terminate()
boxProcess.join()
def main():
"""MAIN"""
cv2.namedWindow("Test") # Create a named window
cv2.moveWindow("Test", 900, 600) # Move it to (40,30)
screenWidth, screenHeight = pyautogui.size()
st = 'Last command'
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sample_frame = cap.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
# Setting up process for listening to audio commands
voice_command_queue = Q()
stt_process = Thread(target=get_voice_command,
args=(voice_command_queue, ))
stt_process.setDaemon(True)
stt_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
tm = cv2.TickMeter()
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cap.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
facebox = box_queue.get()
if facebox is not None:
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]:facebox[3], facebox[0]:facebox[2]]
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
tm.start()
marks = mark_detector.detect_marks([face_img])
tm.stop()
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Uncomment following line to show raw marks.
# mark_detector.draw_marks(
# frame, marks, color=(0, 255, 0))
# Uncomment following line to show facebox.
# mark_detector.draw_box(frame, [facebox])
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
steady_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
steady_pose.append(ps_stb.state[0])
steady_pose = np.reshape(steady_pose, (-1, 3))
# Uncomment following line to draw pose annotation on frame.
# pose_estimator.draw_annotation_box(
# frame, pose[0], pose[1], color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotation on frame.
pose_estimator.draw_annotation_box(frame,
steady_pose[0],
steady_pose[1],
color=(255, 128, 128))
# Uncomment following line to draw head axes on frame.
endpoints = pose_estimator.getEndPoints(frame, steady_pose[0],
steady_pose[1])
deltax = endpoints[1][0] - endpoints[0][0]
deltay = endpoints[1][1] - endpoints[0][1]
xpos = math.floor((deltax + 44) * screenWidth / 88)
ypos = math.floor((deltay + 14) * screenHeight / 58)
# print(xpos, ypos)
pyautogui.moveTo(xpos, ypos)
if not voice_command_queue.empty():
command = voice_command_queue.get_nowait()
if 'click' in command or 'select' in command:
pyautogui.click()
st = 'Click'
elif 'double' in command or 'in' in command:
pyautogui.doubleClick()
st = 'Double Click'
elif 'right' in command or 'menu' in command or 'light' in command:
pyautogui.rightClick()
st = 'Right Click'
print(command)
cv2.putText(frame, st, (0, 100), cv2.FONT_HERSHEY_SIMPLEX, 20, 255)
scale_percent = 30
# calculate the 50 percent of original dimensions
width = int(frame.shape[1] * scale_percent / 100)
height = int(frame.shape[0] * scale_percent / 100)
# dsize
dsize = (width, height)
# resize image
output = cv2.resize(frame, dsize)
cv2.moveWindow("Test", screenWidth - width, screenHeight - height)
# Show preview.
cv2.imshow("Test", output)
if cv2.waitKey(10) == 27:
break
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()
def main():
"""MAIN"""
# Video source from webcam or video file.
video_src = args.cam if args.cam is not None else args.video
if video_src is None:
print(
"Warning: video source not assigned, default webcam will be used.")
video_src = 0
cap = cv2.VideoCapture(video_src)
if video_src == 0:
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sample_frame = cap.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
tm = cv2.TickMeter()
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cap.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
if video_src == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
facebox = box_queue.get()
if facebox is not None:
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]:facebox[3], facebox[0]:facebox[2]]
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
tm.start()
marks = mark_detector.detect_marks([face_img])
tm.stop()
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Uncomment following line to show raw marks.
mark_detector.draw_marks(frame, marks, color=(0, 255, 0))
right_corner = tuple([int(i) for i in marks[36]])
left_corner = tuple([int(i) for i in marks[45]])
# print(marks[36], marks[45])
cv2.line(frame, right_corner, left_corner, (255, 0, 0), 2)
pixel_distance = int(
math.sqrt((right_corner[0] - left_corner[0])**2 +
(right_corner[1] - left_corner[1])**2))
estimated_distance = (real_width * focal_length) / pixel_distance
cv2.putText(frame, str(round(estimated_distance, 2)), (100, 100),
cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 0, 0))
# Uncomment following line to show facebox.
# mark_detector.draw_box(frame, [facebox])
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
steady_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
steady_pose.append(ps_stb.state[0])
steady_pose = np.reshape(steady_pose, (-1, 3))
# Uncomment following line to draw pose annotation on frame.
# pose_estimator.draw_annotation_box(
# frame, pose[0], pose[1], color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotation on frame.
# pose_estimator.draw_annotation_box(
# frame, steady_pose[0], steady_pose[1], color=(128, 255, 128))
# Uncomment following line to draw head axes on frame.
print(steady_pose[1])
pose_estimator.draw_axes(frame, steady_pose[0], steady_pose[1])
angles = process_eyes(frame, marks)
if bool(angles) is True:
# print(angles)
angles = cvt_to_radians(angles)
rotated_vector = rotate_vector(steady_pose[0],
angles['right'][0],
angles['right'][1])
shifted_translation_vector = np.copy(steady_pose[1])
shifted_translation_vector[0] += 50
shifted_translation_vector[1] += 50
pose_estimator.draw_axes(frame, rotated_vector,
shifted_translation_vector)
# Show preview.
cv2.imshow("Preview", frame)
if cv2.waitKey(10) == 27:
break
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()
def headPoseEstimation():
print("HEAD POSE ESTIMATION...")
"""MAIN"""
# Video source from webcam or video file.
#video_src = 0
#video_src = 'EWSN.avi'
#cam = cv2.VideoCapture(video_src)
#_, sample_frame = cam.read()
# Video source from webcam or video file.
video_src = args.cam if args.cam is not None else args.video
if video_src is None:
print(
"Warning: video source not assigned, default webcam will be used.")
video_src = 0
cap = cv2.VideoCapture(video_src)
if video_src == 0:
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sample_frame = cap.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
print("1")
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
print("2")
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
print("3")
noseMarks = [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0],
[0, 0], [0, 0], [0, 0]]
counter = 0
font = cv2.FONT_HERSHEY_SIMPLEX
numXPoints = 0
numYPoints = 0
sumX = 0
sumY = 0
# start = time.time()
# previousTime1 = start
# previousTime2 = start
currentTime = 0
previousTime1 = 0
previousTime2 = 0
directionArray = []
moveSequence = []
moves = []
classifyMoves = 0
headPoseDirection = 'emtpy'
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cap.read()
if frame_got is False:
break
#print("4")
#print(frame.shape)
#print("5")
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
#if video_src == 0:
# print("6")
# frame = cv2.flip(frame, 2)
# cv2.imwrite("Preview.png", frame)
# print("7")
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
#print("8")
# Get face from box queue.
facebox = box_queue.get()
#print(type(facebox)
#print(facebox
#print("9")
if facebox is not None:
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]:facebox[3], facebox[0]:facebox[2]]
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
print(face_img.shape)
marks = mark_detector.detect_marks(face_img)
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# # Get average position of nose
noseMarksTemp = []
noseMarksTemp.append(marks[30][0])
noseMarksTemp.append(marks[30][1])
noseMarks[0] = noseMarksTemp
for i in range(9, 0, -1):
noseMarks[i] = noseMarks[i - 1]
# Get the direction of head movement
headPoseDirection = calculateDirection(noseMarks)
#if headPoseDirection != 'still':
directionArray.append(headPoseDirection)
#print(directionArray
#print(len(directionArray)
print("To capture a movement press 'a' and perform a movement.")
#currentTime1 = time.time()
if cv2.waitKey(5) == ord('a') and not classifyMoves:
classifyMoves = 1
print("Start classifying movement...")
timer = time.time()
currentTime = timer
previousTime1 = timer
previousTime2 = timer
if cv2.waitKey(5) == ord('b') and classifyMoves:
classifyMoves = 0
print("Stopped classifying movement...")
currentTime = time.time()
if currentTime - previousTime1 > 2 and classifyMoves:
print("------------------------------------------------")
print("Elapsed timer 1: " + str(currentTime - previousTime1))
#print(len(directionArray)
# Get most common direction
moveClass = mostCommon(directionArray)
#moveSequence.append(moveClass)
print(moveClass)
# Get a sequence of head movements
# if currentTime - previousTime2 > 10 and classifyMoves == 1 and len(moves) == 0:
# print("Elapsed timer 2: " + str(currentTime - previousTime2)
# numMoves = len(moveSequence)
# moves = moveSequence[(numMoves-5):(numMoves-1)]
# print(moves
# moveSequence = []
# previousTime2 = currentTime
# classifyMoves = 0
classifyMoves = 0
directionArray = []
previousTime1 = currentTime
print(
"To continue type 'c' or to recapture a movement type 'a'."
)
if cv2.waitKey(5) == ord('c'):
break
#print(previousTime
# Uncomment following line to show raw marks.
#mark_detector.draw_marks(frame, marks, color=(0, 255, 0))
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
stabile_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
stabile_pose.append(ps_stb.state[0])
stabile_pose = np.reshape(stabile_pose, (-1, 3))
# Uncomment following line to draw pose annotaion on frame.
# pose_estimator.draw_annotation_box(
# frame, pose[0], pose[1], color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotaion on frame.
#pose_estimator.draw_annotation_box(
# frame, stabile_pose[0], stabile_pose[1], color=(128, 255, 128))
# if len(moves) > 1:
# cv2.putText(frame, moves[0], (450,70), font, 1, (0,0,0), 4)
# cv2.putText(frame, moves[1], (450,100), font, 1, (0,0,0), 4)
# cv2.putText(frame, moves[2], (450,130), font, 1, (0,0,0), 4)
# cv2.putText(frame, moves[3], (450,160), font, 1, (0,0,0), 4)
cv2.putText(frame, headPoseDirection, (20, 70), font, 1, (0, 255, 0),
4)
# Show preview.
#cv2.namedWindow("", cv2.WINDOW_NORMAL)
cv2.imshow("Preview", frame)
#cv2.resizeWindow("preview", 5000,5000)
if cv2.waitKey(5) == 27:
break
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()
return moveClass
def __init__(self):
"""Subscribers"""
rospy.Subscriber("/faces_images",
Faces,
self.callback_face,
queue_size=1)
rospy.Subscriber("/any_detection",
Bool,
self.callback_flag,
queue_size=1)
"""Publishers """
self.quaternion = rospy.Publisher("quaternion",
PoseStamped,
queue_size=1)
self.q = PoseStamped()
self.q.header.frame_id = "map"
self.info = rospy.Publisher("driver_info", driver_info, queue_size=1)
self.msg_driver = driver_info()
"""Node Parameters"""
self.detector = dlib.get_frontal_face_detector()
self.predictor = dlib.shape_predictor(
os.path.join(os.path.dirname(sys.path[0]), 'scripts',
'shape_predictor_68_face_landmarks.dat'))
self.model68 = (os.path.join(os.path.dirname(sys.path[0]), 'scripts',
'model.txt'))
self.size = (rospy.get_param('~img_heigth',
480), rospy.get_param('~img_width', 640))
self.data_buffernose_rs = []
self.data_buffernose_gs = []
self.data_buffernose_bs = []
self.data_bufferforehead_rs = []
self.data_bufferforehead_gs = []
self.data_bufferforehead_bs = []
self.data_buffernose_gray = []
self.data_bufferforehead_gray = []
self.matrix_v = []
self.nose_ica_g = []
self.fore_ica_g = []
self.time_v = []
self.bpm_a = 0
self.window_hr = 0
self.pulso_pantalla = 0
self.pulso_guardado = 0
self.pulso_adquirido = 0
self.cont = 0
self.cont2 = 0
self.cont_yawn = 0
self.flag = 0
self.flag_300 = 0
self.eye_thresh = 0.3
self.mouth_thresh = 0.55
self.num_frames = 2
self.blink_counter = 0
self.total = 0
self.eyes_open = 0.0
self.eyes_closed = 0.0
self.perclos = 0.0
self.mouth_status = False
self.img = None
self.flag_detec = None
"""Parameters for head pose estimation"""
self.model_points_68 = self._get_full_model_points()
img_size = (480, 640)
self.size = img_size
self.focal_length = self.size[1]
self.camera_center = (self.size[1] / 2, self.size[0] / 2)
self.camera_matrix = np.array(
[[self.focal_length, 0, self.camera_center[0]],
[0, self.focal_length, self.camera_center[1]], [0, 0, 1]],
dtype="double")
self.dist_coeefs = np.zeros((4, 1))
self.r_vec = np.array([[0.01891013], [0.08560084], [-3.14392813]])
self.t_vec = np.array([[-14.97821226], [-10.62040383],
[-2053.03596872]])
self.pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
self.main()
def main():
"""MAIN"""
# Video source from webcam or video file.
video_src = args.cam if args.cam is not None else args.video
if video_src is None:
print("Warning: video source not assigned, default webcam will be used.")
video_src = 0
cap = cv2.VideoCapture(video_src)
if video_src == 0:
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sample_frame = cap.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face, args=(
mark_detector, img_queue, box_queue,))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
if args.out != None:
fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')
output_movie = cv2.VideoWriter(args.out, fourcc, 30, (width, height))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [Stabilizer(
state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)]
tm = cv2.TickMeter()
cnt = 0
input_path = args.input_path
listdir = os.listdir(input_path)
for v_name in listdir:
v_path = os.path.join(input_path, v_name)
cap = cv2.VideoCapture(v_path)
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cap.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
if video_src == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
facebox = box_queue.get()
if facebox is not None:
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]: facebox[3],
facebox[0]: facebox[2]]
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
tm.start()
marks = mark_detector.detect_marks(face_img)
tm.stop()
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Uncomment following line to show raw marks.
# mark_detector.draw_marks(frame, marks, color=(0, 255, 0))
# Uncomment following line to show facebox.
# mark_detector.draw_box(frame, [facebox])
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
steady_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
steady_pose.append(ps_stb.state[0])
steady_pose = np.reshape(steady_pose, (-1, 3))
# Uncomment following line to draw pose annotation on frame.
# pose_estimator.draw_annotation_box(
# frame, pose[0], pose[1], color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotation on frame.
pose_estimator.draw_annotation_box(
frame, steady_pose[0], steady_pose[1], color=(128, 255, 128))
# Uncomment following line to draw head axes on frame.
# pose_estimator.draw_axes(frame, steady_pose[0], steady_pose[1])
# Show preview.
# cv2.imshow("Preview", frame)
# if cv2.waitKey(10) == 27:
# break
if args.out != None:
output_movie.write(frame)
else:
cv2.imshow("Preview", frame)
cnt = cnt + 1
if cnt % 100 == 0:
print(str(cnt), flush=True)
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()
cv2.destroyAllWindows()
def main():
"""MAIN"""
# Video source from webcam or video file.
video_src = args.cam if args.cam is not None else args.video
if video_src is None:
engine.say(
"Warning: video source not assigned, default webcam will be used")
engine.runAndWait()
video_src = 0
cap = cv2.VideoCapture(video_src)
if video_src == 0:
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
_, sample_frame = cap.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face,
args=(
mark_detector,
img_queue,
box_queue,
))
box_process.start()
gaze = GazeTracking()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [
Stabilizer(state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)
]
tm = cv2.TickMeter()
head_flag = 0
gaze_flag = 0
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cap.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
#audio_record(AUDIO_OUTPUT, 3)
#sphinx_recog(AUDIO_OUTPUT)
# If frame comes from webcam, flip it so it looks like a mirror.
if video_src == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
facebox = box_queue.get()
gaze.refresh(frame)
frame = gaze.annotated_frame()
text = ""
if facebox is not None:
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]:facebox[3], facebox[0]:facebox[2]]
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
gray = cv2.cvtColor(face_img, cv2.COLOR_BGR2GRAY)
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
rects = detector(gray, 0)
tm.start()
marks = mark_detector.detect_marks([face_img])
tm.stop()
#
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) #converting to NumPy Array矩阵运算
mouth = shape[Start:End]
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye) #眼睛长宽比
rightEAR = eye_aspect_ratio(rightEye)
ear = (leftEAR + rightEAR) / 2.0 #长宽比平均值
lipdistance = lip_distance(shape)
if (lipdistance > YAWN_THRESH):
#print(lipdistance)
flag0 += 1
print("yawning time: ", flag0)
if flag0 >= 40:
cv2.putText(frame, "Yawn Alert", (10, 150),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255),
2)
cv2.putText(frame, "Yawn Alert", (220, 150),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255),
2)
engine.say("don't yawn")
engine.runAndWait()
flag0 = 0
else:
flag0 = 0
if (ear < thresh):
flag += 1
print("eyes closing time: ", flag)
if flag >= frame_check:
cv2.putText(frame,
"****************ALERT!****************",
(10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(0, 0, 255), 2)
cv2.putText(frame,
"****************ALERT!****************",
(10, 250), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(0, 0, 255), 2)
engine.say("open your eyes")
engine.runAndWait()
flag = 0
else:
flag = 0
if gaze.is_right():
print("Looking right")
text = "Looking right"
elif gaze.is_left():
print("Looking left")
text = "Looking left"
elif gaze.is_up():
text = "Looking up"
else:
text = "Looking center"
if text is not "Looking center":
gaze_flag += 1
if gaze_flag >= 20:
engine.say("look forward")
engine.runAndWait()
gaze_flag = 0
else:
gaze_flag = 0
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Uncomment following line to show raw marks.
# mark_detector.draw_marks(
# frame, marks, color=(0, 255, 0))
# Uncomment following line to show facebox.
# mark_detector.draw_box(frame, [facebox])
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# get angles
angles = pose_estimator.get_angles(pose[0], pose[1])
if ((-8 > angles[0] or angles[0] > 8)
or (-8 > angles[1] or angles[1] > 8)):
head_flag += 1
if head_flag >= 40:
print(angles[0])
engine.say("please look ahead")
engine.runAndWait()
else:
head_flag = 0
# pose_estimator.draw_info(frame, angles)
# Stabilize the pose.
steady_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
steady_pose.append(ps_stb.state[0])
steady_pose = np.reshape(steady_pose, (-1, 3))
# Uncomment following line to draw pose annotation on frame.
pose_estimator.draw_annotation_box(frame,
pose[0],
pose[1],
color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotation on frame.
pose_estimator.draw_annotation_box(frame,
steady_pose[0],
steady_pose[1],
color=(128, 255, 128))
# Uncomment following line to draw head axes on frame.
pose_estimator.draw_axes(frame, steady_pose[0], steady_pose[1])
#pose_estimator.show_3d_model
# Show preview.
cv2.imshow("Preview", frame)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()
def main():
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-m", "--draw-markers", action="store_true", default=False,
help="")
ap.add_argument("-c", "--draw-confidence", action="store_true", default=False,
help="")
ap.add_argument("-t", "--confidence-threshold", type=float, default=0.9,
help="")
ap.add_argument("-p", "--draw-pose", action="store_false", default=True,
help="")
ap.add_argument("-u", "--draw-unstable", action="store_true", default=False,
help="")
ap.add_argument("-s", "--draw-segmented", action="store_true", default=False,
help="")
args = vars(ap.parse_args())
confidence_threshold = args["confidence_threshold"]
"""MAIN"""
# Video source from webcam or video file.
video_src = 0
cam = cv2.VideoCapture(video_src)
_, sample_frame = cam.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
if isWindows():
thread = threading.Thread(target=get_face, args=(mark_detector, confidence_threshold, img_queue, box_queue))
thread.daemon = True
thread.start()
else:
box_process = Process(target=get_face,
args=(mark_detector, confidence_threshold, img_queue, box_queue))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [Stabilizer(
state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)]
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cam.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
if video_src == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
result = box_queue.get()
if result is not None:
if args["draw_confidence"]:
mark_detector.face_detector.draw_result(frame, result)
# unpack result
facebox, confidence = result
# fix facebox if needed
if facebox[1] > facebox[3]:
facebox[1] = 0
if facebox[0] > facebox[2]:
facebox[0] = 0
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]: facebox[3],
facebox[0]: facebox[2]]
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
marks = mark_detector.detect_marks(face_img)
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# segment the image based on markers and facebox
seg = Segmenter(facebox, marks, frame.shape[1], frame.shape[0])
if args["draw_segmented"]:
mark_detector.draw_box(frame, seg.getSegmentBBs())
cv2.imshow("fg", seg.getSegmentJSON()["faceGrid"])
if args["draw_markers"]:
mark_detector.draw_marks(
frame, marks, color=(0, 255, 0))
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
stable_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
stable_pose.append(ps_stb.state[0])
stable_pose = np.reshape(stable_pose, (-1, 3))
if args["draw_unstable"]:
pose_estimator.draw_annotation_box(
frame, pose[0], pose[1], color=(255, 128, 128))
if args["draw_pose"]:
pose_estimator.draw_annotation_box(
frame, stable_pose[0], stable_pose[1], color=(128, 255, 128))
# Show preview.
cv2.imshow("Preview", frame)
if cv2.waitKey(10) == 27:
break
# Clean up the multiprocessing process.
if not isWindows():
box_process.terminate()
box_process.join()
def main():
"""MAIN"""
# Video source from webcam or video file.
video_src = 0
cam = cv2.VideoCapture(video_src)
_, sample_frame = cam.read()
# Introduce mark_detector to detect landmarks.
mark_detector = MarkDetector()
# Setup process and queues for multiprocessing.
img_queue = Queue()
box_queue = Queue()
img_queue.put(sample_frame)
box_process = Process(target=get_face, args=(
mark_detector, img_queue, box_queue,))
box_process.start()
# Introduce pose estimator to solve pose. Get one frame to setup the
# estimator according to the image size.
height, width = sample_frame.shape[:2]
pose_estimator = PoseEstimator(img_size=(height, width))
# Introduce scalar stabilizers for pose.
pose_stabilizers = [Stabilizer(
state_num=2,
measure_num=1,
cov_process=0.1,
cov_measure=0.1) for _ in range(6)]
while True:
# Read frame, crop it, flip it, suits your needs.
frame_got, frame = cam.read()
if frame_got is False:
break
# Crop it if frame is larger than expected.
# frame = frame[0:480, 300:940]
# If frame comes from webcam, flip it so it looks like a mirror.
if video_src == 0:
frame = cv2.flip(frame, 2)
# Pose estimation by 3 steps:
# 1. detect face;
# 2. detect landmarks;
# 3. estimate pose
# Feed frame to image queue.
img_queue.put(frame)
# Get face from box queue.
facebox = box_queue.get()
if facebox is not None:
# Detect landmarks from image of 128x128.
face_img = frame[facebox[1]: facebox[3],
facebox[0]: facebox[2]]
face_img = cv2.resize(face_img, (CNN_INPUT_SIZE, CNN_INPUT_SIZE))
face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
marks = mark_detector.detect_marks(face_img)
# Convert the marks locations from local CNN to global image.
marks *= (facebox[2] - facebox[0])
marks[:, 0] += facebox[0]
marks[:, 1] += facebox[1]
# Uncomment following line to show raw marks.
# mark_detector.draw_marks(
# frame, marks, color=(0, 255, 0))
# Try pose estimation with 68 points.
pose = pose_estimator.solve_pose_by_68_points(marks)
# Stabilize the pose.
stabile_pose = []
pose_np = np.array(pose).flatten()
for value, ps_stb in zip(pose_np, pose_stabilizers):
ps_stb.update([value])
stabile_pose.append(ps_stb.state[0])
stabile_pose = np.reshape(stabile_pose, (-1, 3))
# Uncomment following line to draw pose annotaion on frame.
# pose_estimator.draw_annotation_box(
# frame, pose[0], pose[1], color=(255, 128, 128))
# Uncomment following line to draw stabile pose annotaion on frame.
pose_estimator.draw_annotation_box(
frame, stabile_pose[0], stabile_pose[1], color=(128, 255, 128))
# Show preview.
cv2.imshow("Preview", frame)
if cv2.waitKey(10) == 27:
break
# Clean up the multiprocessing process.
box_process.terminate()
box_process.join()