def process_video(file_name, n=1):
"""
iterate over frames of videofile
:param file_name: filename
:param n:process one out of every n frames-> default 1: take all frames
:return:list of finish frames
"""
fvs = FileVideoStream(file_name).start() #load video
cam = cv2.VideoCapture(file_name)
fps = cam.get(cv2.CAP_PROP_FPS) #get original fps of video
counter = 1
frame_list = []
teller = 0
while fvs.running():
if fvs.more():
teller += 1
frame = fvs.read()
if frame is not None:
frame_list.append(
cv2.resize(
frame,
(int(frame.shape[1] / 2), int(frame.shape[0] / 2)))
) #append frame to list and resize it: height/2, width/2
counter += 1
else:
time.sleep(2)
return (frame_list, fps)
def run_detection(fast_mtcnn, filenames):
frames = []
frames_processed = 0
faces_detected = 0
batch_size = 60
start = time.time()
for filename in tqdm(filenames):
v_cap = FileVideoStream(filename).start()
v_len = int(v_cap.stream.get(cv2.CAP_PROP_FRAME_COUNT))
for j in range(v_len):
frame = v_cap.read()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frames.append(frame)
if len(frames) >= batch_size or j == v_len - 1:
faces = fast_mtcnn(frames)
for i in range(len(faces)):
file_name = str(j) + str(i) + '.jpg'
# cv2.imwrite(file_name,faces[i])
#print(faces)
frames_processed += len(frames)
faces_detected += len(faces)
frames = []
print(
f'Frames per second: {frames_processed / (time.time() - start):.3f},',
f'faces detected: {faces_detected}\r',
end='')
v_cap.stop()
def main():
# Get ROI from frames
file_name = "/home/smart/WBC286 InvL-Pillars -35mbar 15fps 29-11-2019 v3.4.avi"
#file_name = "C:/Users/Me/Desktop/capstone/WBC286 InvL-Pillars -350mbar 150fps 29-11-2019 v3.4.avi"
cap = FileVideoStream(file_name).start()
image = cap.read()
print("***** PROCESSING ROI for RUN 1 ***** File: %s" % file_name)
cap.stop()
print("***** PROCESSING RUN 1 ***** File: %s" % file_name)
print("Frame size: ", image.shape)
Channels = 34
#original size: [502,1402,3]
# r = [84, 357, 1238, 130]
r = [
int(0.167 * image.shape[0]),
int(0.25 * image.shape[1]),
int(0.883 * image.shape[1]), 130
]
x1, x2, y1, y2, sub_ch, channel_len = to_crop(image, r, Channels)
# run count
run_standard = standard(file_name, Channels)
(fps) = run_standard.standard_run(x1, x2, y1, y2, sub_ch, channel_len)
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
rbc_counts = run_standard.rbc_detection()
run_standard.process_results(rbc_counts)
print(
"----------------------------------------------------------------------"
)
def UAMS(self):
video_file = FileVideoStream(self.args["video"]).start()
time.sleep(2.0)
fps = FPS().start()
while video_file.more():
# Converting each frame to matrix of numbers
try:
self.frame = video_file.read()
gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)
gray = np.dstack([gray, gray, gray])
except Exception as e:
print(e)
self.frame, self.faces, conf, detection, startX, y = self.cnn_op.CNNOperation(
self.frame, self.net, self.args)
try:
msg = self.calculation(startX, y)
except Exception as e:
print(e)
try:
cv2.imshow("frame-this is main frame", self.frame)
except Exception as e:
print(e)
fps.update()
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
fps.stop()
print("elapsed time : {:.2f}".format(fps.elapsed()))
print("FPS : {:.2f}".format(fps.fps()))
def face_verification(self, path):
"""
Face verification from input file video Stream
:param path: Location of the video
:return name: Recognized person's name
"""
video_path = path
result = True
while (result):
vs = FileVideoStream(video_path).start()
frame = vs.read()
frame = ndimage.rotate(frame, 180)
frame = ndimage.rotate(frame, 90)
cap_image = frame
check = SPOOF_DETECTION().spoof_detection(video_path)
result = False
vs.stop()
cv2.destroyAllWindows()
if check == True:
name = obj.face_recognize(cap_image)
print('Recognized image {}'.format(name))
else:
print('SPOOFING ')
class VideoStreamer(Camera):
def __init__(self, src=0, use_pi=-1, resolution=480, framerate=30):
super(VideoStreamer, self).__init__(use_pi=use_pi,
resolution=resolution,
framerate=framerate)
# VideoStream class is used for live stream.
# FileVideoStream class is used for streaming from a saved video.
if isinstance(src, int):
self.vs = VideoStream(src=src,
usePiCamera=self.use_pi > 0,
resolution=self.resolution,
framerate=self.framerate).start()
else:
self.vs = FileVideoStream(path=src)
# Let camera warm up
time.sleep(1.0)
# Returns the frame as a np array
def read(self):
if isinstance(self.vs, FileVideoStream):
return self.vs.stream.read()[1]
else:
return self.vs.read()
# Terminate the capture thread.
def stop(self):
self.vs.stop()
def OfflineVideo():
# a function to initialize an pre-recorded video for offfline analysis
print "[INFO] - All *.avi files in .." + chr(92) + "videos" + chr(
92) + ":"
for file in os.listdir("videos"): # show the content of the videos folder
if "avi" in file: # only print avi files
print file
Selection = raw_input("select file to play (without extension): "
) # ask user to type in the file to play
if Selection == "": # if nothing is entered
#vs = cv2.VideoCapture("videos" + chr(92) + "LongVideo1_quer" + ".avi") # take the default video
camera = FileVideoStream("videos" + chr(92) + "LongVideo1_quer" +
".avi").start()
else:
if os.path.isfile("videos" + chr(92) + Selection +
".avi"): # check if the file is existing
camera = FileVideoStream(
"videos" + chr(92) + Selection + ".avi"
).start(
) # take the file defined by the user if it is existing in the video folder
print "[INFO] - Selected file: " + str(camera)
else:
print "[INFO] - File not found!" # if file was not found,
OfflineVideo() # restart function and re-ask for name
return camera
class ImageRouter(QtCore.QObject):
source_is_file = False
on_frame = QtCore.pyqtSignal(np.ndarray)
def __init__(self, filename=''):
super().__init__()
if filename == '':
self.vs = VideoStream(src=0).start()
self.source_is_file = False
else:
self.vs = FileVideoStream(filename).start()
self.source_is_file = True
def __del__(self):
self.vs.stop()
def tick(self):
if self.source_is_file and not self.vs.more():
return False
frame = self.vs.read()
if frame is None:
return False
self.on_frame.emit(frame)
return True
def run(self):
print("[INFO] Started ImageRouter")
while self.tick():
None
print("[INFO] Stopped ImageRouter")
def start (self):
if self.filename is not None:
self.log.debug('Video file: %s', self.filename)
self.fvs = FileVideoStream(self.filename).start()
self.stream = self.fvs.stream
time.sleep(1.0)
else:
if self.use_pi_camera:
self.log.debug('Pi Camera (%d %d)', self.resolution[0], self.resolution[1])
self.stream = VideoStream(src=0,
usePiCamera=True,
resolution=self.resolution,
framerate=self.framerate,
sensor_mode=5
).start()
else:
self.log.debug('Web Camera')
self.stream = cv2.VideoCapture(0)
self.stream.set(cv2.CAP_PROP_BUFFERSIZE, 2)
self.resolution = (
self.stream.get(cv2.CAP_PROP_FRAME_WIDTH),
self.stream.get(cv2.CAP_PROP_FRAME_HEIGHT)
)
self.framerate = self.stream.get(cv2.CAP_PROP_FPS)
return self.resolution, self.framerate
def scan_file(self, fname):
vs = FileVideoStream(fname).start()
while True:
frame = vs.read()
# frame = imutils.resize(frame)
barcodes = pyzbar.decode(frame)
for code in barcodes:
(x, y, w, h) = code.rect
cv2.rectangle(frame, (x, y), (x + w, x + h), (0, 0, 255), 2)
bar_data = code.data.decode('utf-8')
bar_type = code.type
text = f'{bar_data} ({bar_type})'
cv2.putText(frame, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 0, 255), 2)
cv2.imshow("Barcode Scanner", frame)
key = cv2.waitKey(1) & 0xFF
if key == ord('q'):
break
cv2.destroyAllWindows()
vs.stop()
class VideoCamera(object):
def __init__(self):
# Using OpenCV to capture from device 0. If you have trouble capturing
# from a webcam, comment the line below out and use a video file
# instead.
# self.video = cv2.VideoCapture(0)
# If you decide to use video.mp4, you must have this file in the folder
# as the main.py.
self.video = FileVideoStream("cropvideo.mp4").start()
def __del__(self):
self.video.release()
def get_frame(self):
image = self.video.read()
faceCascade = cv2.CascadeClassifier('haarcascade_profileface.xml')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(gray, 1.1, 4)
# We are using Motion JPEG, but OpenCV defaults to capture raw images,
# so we must encode it into JPEG in order to correctly display the
# video stream.
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
ret, jpeg = cv2.imencode('.jpg', image)
return jpeg.tobytes()
def __init__(self, kwargs):
self.args = kwargs
# 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(SHAPE_PREDICTOR)
# grab the indexes of the facial landmarks for the left and
# right eye, respectively
(self.l_start,
self.l_end) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(self.r_start,
self.r_end) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
# start the video stream thread
print("[INFO] starting video stream thread...")
try:
video_src = int(self.args["webcam"])
print('[INFO] Using webcam...')
self.vs = VideoStream(src=video_src).start()
except:
print('[INFO] Using video file...')
self.vs = FileVideoStream(path=self.args["webcam"]).start()
time.sleep(1.0)
def __init__(self, src=0, use_cv2=False):
if use_cv2:
self.obj = cv2.VideoCapture(src)
elif src == 0:
self.obj = WebcamVideoStream(src)
elif src != 0:
self.obj = FileVideoStream(src)
def eye_close(image):
path = "shape_predictor_68_face_landmarks.dat"
predictor = dlib.shape_predictor(path)
detector = dlib.get_frontal_face_detector()
EYE_AR_THRESH = 0.4
(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"]
vs = FileVideoStream(image).start()
time.sleep(2.0)
frame = vs.read()
frame = imutils.resize(frame, width=400)
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)
return leftEAR, rightEAR
def Start(self, filename):
'''
Parameters:
`filename` path of the video file
'''
self.shape_predictor = ".\\shape_predictor_68_face_landmarks.dat"
self.detector = dlib.get_frontal_face_detector()
self.predictor = dlib.shape_predictor(self.shape_predictor)
self.vs = FileVideoStream(filename).start()
fileStream = True
time.sleep(1)
print("Arranging video frames ...")
while self.vs.more():
frame = self.vs.read()
# Transpose and flip statements performed everytime the orientation
# of
# the video passed is not
# initially correct.
#frame = cv2.transpose(frame)
frame = cv2.flip(
frame, flipCode=1
) # HACK: this tweak depends on the original video orientation.
frame = imutils.resize(frame, width=350)
self.frames.append(frame)
print('Done!')
self.InitPlot()
self.ReadFrames()
def init_stream(self, camera=0):
if type(camera) == type(1):
self.camera = camera;
self.web_cam = True
self.file = ''
try:
self.vs = VideoStream1(self.camera)
self.err_open_stream = False
except:
self.err_open_stream = True
logger.info('can not open stream')
elif type(camera) == type('string'):
self.camera = -1;
self.web_cam = False
self.file = camera
try:
self.vs = FileVideoStream(self.file)
self.err_open_stream = False
except:
self.err_open_stream = True
logger.info('can not open file')
#sleep(0.1) # time to worm-up camera
self.processed_frames = 0# number of processed frames in current time window
def __init__(self, src, ind):
super(CustomMainThread, self).__init__()
self.src = src # the input camera/video source link
self.fvs = FileVideoStream(self.src, queue_size=64).start()
self.ind = ind
self.inputQ = self.fvs.Q
self.obj = AllBehaviours()
class VideoSource (object):
def __init__ (self, video_file, log, use_pi_camera = True, resolution=(320, 200), framerate = 30, night = False):
self.filename = video_file
self.log = log
self.use_pi_camera = use_pi_camera
self.resolution = resolution
self.framerate = framerate
self.night = night
self.fvs = None
self.stream = None
self._done = False
def start (self):
if self.filename is not None:
self.log.debug('Video file: %s', self.filename)
self.fvs = FileVideoStream(self.filename).start()
self.stream = self.fvs.stream
time.sleep(1.0)
else:
if self.use_pi_camera:
self.log.debug('Pi Camera (%d %d)', self.resolution[0], self.resolution[1])
self.stream = VideoStream(src=0,
usePiCamera=True,
resolution=self.resolution,
framerate=self.framerate,
sensor_mode=5
).start()
else:
self.log.debug('Web Camera')
self.stream = cv2.VideoCapture(0)
self.stream.set(cv2.CAP_PROP_BUFFERSIZE, 2)
self.resolution = (
self.stream.get(cv2.CAP_PROP_FRAME_WIDTH),
self.stream.get(cv2.CAP_PROP_FRAME_HEIGHT)
)
self.framerate = self.stream.get(cv2.CAP_PROP_FPS)
return self.resolution, self.framerate
def read(self):
if self.filename:
frame = self.fvs.read()
else:
frame = self.stream.read()
return frame
def stop (self):
if self.filename:
self.fvs.stop()
else:
self.stream.stop()
self._done = True
def done(self):
# check to see if video is still running
running = (self.filename and self.fvs.running()) or True
self._done = not running
return self._done
def main(_argv):
input_layer = tf.keras.layers.Input([FLAGS.size, FLAGS.size, 3])
feature_maps = YOLOv4(input_layer, NUM_CLASS)
bbox_tensors = []
for i, fm in enumerate(feature_maps):
bbox_tensor = decode(fm, NUM_CLASS, i)
bbox_tensors.append(bbox_tensor)
model = tf.keras.Model(input_layer, bbox_tensors)
utils.load_weights(model, 'data/YOLOv4-obj_1000.weights')
vid = FileVideoStream(FLAGS.input) # Reading input
return_value, frame = vid.read()
fourcc = cv2.VideoWriter_fourcc('F', 'M', 'P', '4')
out = cv2.VideoWriter(FLAGS.output, fourcc, 10.0,
(frame.shape[1], frame.shape[0]), True)
plates = []
n = 0
Sum = 0
while True:
start = time.time()
n += 1
return_value, frame = vid.read()
if frame is None:
continue
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
bboxes = plateDetect(frame, FLAGS.size,
model) # License plate detection
for i in range(len(bboxes)):
img = frame[int(bboxes[i][1]):int(bboxes[i][3]),
int(bboxes[i][0]):int(bboxes[i][2])]
prediction_groups = pipeline.recognize(
[img]) # Text detection and recognition on license plate
string = ''
for j in range(len(prediction_groups[0])):
string = string + prediction_groups[0][j][0].upper()
if platePattern(string) == True and string not in plates:
plates.append(string)
if len(plates) > 0:
drawText(frame, plates)
frame = utils.draw_bbox(
frame, bboxes) # Draws bounding box around license plate
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
Sum += time.time() - start
print('Avg fps:- ', Sum / n)
out.write(frame)
cv2.imshow("result", frame)
if cv2.waitKey(1) == 27: break
out.release()
cv2.destroyAllWindows()
def standard_run(
self,
x1: int,
x2: int,
y1: int,
y2: int,
sub_ch: list,
channel_len,
):
fps = FPS().start()
cap = FileVideoStream(self.filename).start()
count = 0
start = time.time()
cycle_start = time.time()
frame = cap.read()
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
while cap.more():
# print(count)
frame = cap.read()
if frame is None:
break
if count < 200:
self.frames_buffer.append(frame)
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
frame = frame[y1:y2, x1:x2]
crop = self.mask.apply(frame)
crop = cv2.GaussianBlur(crop, (7, 7), 3.0)
_, crop = cv2.threshold(crop, 150, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
contours, hierarchy = cv2.findContours(crop, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
for i in range(len(contours)):
avg = np.mean(contours[i], axis=0)
coord = (int(avg[0][0]), int(avg[0][1])) # Coord is (x,y)
ch_pos = int(math.floor((coord[0]) / channel_len))
try:
self.sum_ch1[ch_pos] += float(1)
except:
pass
count += 1
fps.update()
fps.stop()
cycle_end = time.time()
self.cycle_count += 1
end = time.time()
detect_benchmark = end - start
print("Number of frames processed: ", count)
print("Time taken for WBC counting:", detect_benchmark)
print("[INFO] Each cycle time taken = %0.5fs" %
((cycle_end - cycle_start) / count))
return fps
def detect_object(frameCount):
# grab global references to the video stream, output frame, and
# lock variables
global vs, outputFrame, lock
# initialize the motion detector and the total number of frames
# read thus far
total = 0
# loop over the frames from the video stream
while True:
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 400 pixels
frame = vs.read()
# time.sleep(0.05)
if frame is None:
print(
"INFO: unable to connect to a webcam, using file stream instead"
)
vs = FileVideoStream("static/test_video.mp4").start()
frame = vs.read()
continue
frame = imutils.resize(frame, width=400)
# grab the frame dimensions and convert it to a blob
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 0.007843,
(300, 300), 127.5)
# pass the blob through the network and obtain the detections and predictions
net.setInput(blob)
detections = net.forward()
# loop over the detections
for i in np.arange(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with the prediction
confidence = detections[0, 0, i, 2]
# filter out weak detections by ensuring the `confidence` is
# greater than the minimum confidence
if confidence > args["confidence"]:
# extract the index of the class label from the
# `detections`, then compute the (x, y)-coordinates of
# the bounding box for the object
idx = int(detections[0, 0, i, 1])
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
# draw the prediction on the frame
label = "{}: {:.2f}%".format(CLASSES[idx], confidence * 100)
cv2.rectangle(frame, (startX, startY), (endX, endY),
COLORS[idx], 2)
y = startY - 15 if startY - 15 > 15 else startY + 15
cv2.putText(frame, label, (startX, y),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLORS[idx], 2)
# acquire the lock, set the output frame, and release the lock
with lock:
outputFrame = frame.copy()
def __init__(self, filename=''):
super().__init__()
if filename == '':
self.vs = VideoStream(src=0).start()
self.source_is_file = False
else:
self.vs = FileVideoStream(filename).start()
self.source_is_file = True
def __init__(self):
# Using OpenCV to capture from device 0. If you have trouble capturing
# from a webcam, comment the line below out and use a video file
# instead.
# self.video = cv2.VideoCapture(0)
# If you decide to use video.mp4, you must have this file in the folder
# as the main.py.
self.video = FileVideoStream("cropvideo.mp4").start()
def frames():
camera = FileVideoStream()
time.sleep(1.0)
# loop over frames from the video file stream
while camera.more():
frame = camera.read()
yield frame
def showVideo(app):
fvs = FileVideoStream(app.vidDir).start()
time.sleep(1.0)
while fvs.more():
frame = fvs.read()
frame = cv2.resize(frame, (720, 480))
cv2.imshow("Frame", frame)
cv2.waitKey(1)
def __init__(self):
#self.cap = cv2.VideoCapture(1)
self.fvs = FileVideoStream(1)
# self.fvs.stream.set(3,FULL_WIDTH)
# self.fvs.stream.set(4,FULL_HEIGHT)
self.fvs.start()
def detect_motion(frameCount):
# grab global references to the video stream, output frame, and
# lock variables
global vs, outputFrame, lock
# initialize the motion detector and the total number of frames
# read thus far
md = SingleMotionDetector(accumWeight=0.1)
total = 0
# loop over frames from the video stream
while True:
# read the next frame from the video stream, resize it,
# convert the frame to grayscale, and blur it
frame = vs.read()
time.sleep(0.05)
if frame is None:
print(
"INFO: unable to connect to a webcam, using file stream instead"
)
vs = FileVideoStream("video/test_video.mp4").start()
frame = vs.read()
continue
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
# grab the current timestamp and draw it on the frame
timestamp = datetime.datetime.now()
cv2.putText(frame, timestamp.strftime("%A %d %B %Y %I:%M:%S%p"),
(10, frame.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35,
(0, 0, 255), 1)
# if the total number of frames has reached a sufficient
# number to construct a reasonable background model, then
# continue to process the frame
if total > frameCount:
# detect motion in the image
motion = md.detect(gray)
# cehck to see if motion was found in the frame
if motion is not None:
# unpack the tuple and draw the box surrounding the
# "motion area" on the output frame
(thresh, (minX, minY, maxX, maxY)) = motion
cv2.rectangle(frame, (minX, minY), (maxX, maxY), (0, 0, 255),
2)
# update the background model and increment the total number
# of frames read thus far
md.update(gray)
total += 1
# acquire the lock, set the output frame, and release the
# lock
with lock:
outputFrame = frame.copy()
def write_svg_haar(stream_url):
'''
Reads an alternative face detection model, and connects to the in-memory
Redis database. Detects faces (no identification) in the specified stream
and calculates the corresponding bounding boxes. Writes the bounding boxes
for all detected faces to an svg overlay which is then saved to
Redis to be accessed by other processes.
'''
print("[INFO] opening redis connection")
redis_db = redis.StrictRedis(host="localhost", port=6379, db=0)
print("[INFO] starting stream")
# capture = cv2.VideoCapture(stream_url)
# capture.set(cv2.CAP_PROP_BUFFERSIZE, 0)
fvs = FileVideoStream(stream_url, queue_size=1).start()
process_this_frame = True
while True:
# if process_this_frame:
if True:
# read_flag, img = capture.read()
if not fvs.more():
continue
img = fvs.read()
face_cascade = cv2.CascadeClassifier(
"./haarcascade_frontalface_default.xml")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, minSize=(20, 20))
svg_document = svgwrite.Drawing(size=("1280px", "720px"))
svg_document.add(
svg_document.rect(insert=(0, 0),
size=("1280px", "720px"),
stroke_width="10",
stroke="green",
fill="rgb(0,0,0)",
fill_opacity=0))
for (x, y, w, h) in faces:
x = int(x)
y = int(y)
svg_document.add(
svg_document.rect(insert=(x, y),
size=("{}px".format(w),
"{}px".format(h)),
stroke_width="10",
stroke="yellow",
fill="rgb(0,0,0)",
fill_opacity=0))
redis_db.set('overlay', svg_document.tostring())
process_this_frame = not process_this_frame
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
def piscadas():
vs = FileVideoStream(0).start()
fileStream = True
EYE_AR_THRESH = 0.3
EYE_AR_CONSEC_FRAMES = 3
COUNTER = 0
TOTAL = 0
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
while True:
if fileStream and not vs.more():
break
frame = vs.read()
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 = get_ear(leftEye)
rightEAR = get_ear(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:
COUNTER += 1
else:
if COUNTER >= EYE_AR_CONSEC_FRAMES:
TOTAL += 1
COUNTER = 0
cv2.putText(frame, "Piscadas: {}".format(TOTAL), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
def load_video(self):
"""
Accelerated video stream with multi-threading support
:return:
"""
if self.verbose:
logging.info(msg=f"{self.video_path} is loading ..")
if self.if_exist():
self.video = FileVideoStream(self.video_path)
import sys
import cv2
import time
from imutils.video import FileVideoStream
videoFile = sys.argv[1]
outputDir = sys.argv[2]
fvs = FileVideoStream(videoFile).start()
time.sleep(1.0)
frameIndex = 0
while (fvs.more()):
frame = fvs.read()
cv2.imshow("Frame", frame)
fileName = outputDir + "\\frame_" + str(frameIndex) + ".tiff"
cv2.imwrite(fileName, frame)
frameIndex += 1
cv2.waitKey(1)
cv2.destroyAllWindows()
fvs.stop()
def filterFrame(frame):
frame = imutils.resize(frame, width=450)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame = np.dstack([frame, frame, frame])
return frame
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-v", "--video", required=True,
help="path to input video file")
args = vars(ap.parse_args())
# start the file video stream thread and allow the buffer to
# start to fill
print("[INFO] starting video file thread...")
fvs = FileVideoStream(args["video"], transform=filterFrame).start()
time.sleep(1.0)
# start the FPS timer
fps = FPS().start()
# loop over frames from the video file stream
while fvs.running():
# grab the frame from the threaded video file stream, resize
# it, and convert it to grayscale (while still retaining 3
# channels)
frame = fvs.read()
# Relocated filtering into producer thread with transform=filterFrame
# Python 2.7: FPS 92.11 -> 131.36
# Python 3.7: FPS 41.44 -> 50.11
