def detect_motion(frameCount):
global vs, outputFrame, lock
# 가중치 파일을 사용한 움직임 검출 클래스
md = SingleMotionDetector(accumWeight=0.1)
total = 0
while True:
frame = vs.read()
frame = imutils.resize(frame, width=400)
# 영상 처리가 용이한 Gray 스케일로 변환
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 엣지 검출을 통한 빠른 모션 감지를 위해 선형 필터인 가우시안 필터 적용.
gray = cv2.GaussianBlur(gray, (7, 7), 0)
# 타임 스탬프를 화면 좌측 하단에 출력
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 total > frameCount:
motion = md.detect(gray)
if motion is not None:
(thresh, (minX, minY, maxX, maxY)) = motion
cv2.rectangle(frame, (minX, minY), (maxX, maxY), (0, 0, 255),
2)
md.update(gray)
total += 1
with lock:
outputFrame = frame.copy()
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
try:
# loop over frames from the video stream
# read the next frame from the video stream, resize it,
while True:
# convert the frame to grayscale, and blur it
start = time.time()
frame = vs.read()
# 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
fps = (1 / (time.time() - start))
info = {'FPS': fps}
add_text_overlays(frame, **info)
writer.write(frame)
# acquire the lock, set the output frame, and release the
# lock
with lock:
outputFrame = frame.copy()
except KeyboardInterrupt:
# quit
print('this is a leave message')
sys.exit()
def detect_motion(frameCount):
global vs, outputFrame, lock
md = SingleMotionDetector(accumWeight=0.1)
total = 0
while True:
frame = vs.read()
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.Color_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
timestamp = datatime.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 total > frameCount:
motion = md.detect(gray)
if motion is not None:
(thresh, (minX, minY, maxX, maxY)) = motion
cv2.rectangle(frame, (minX, minY), (maxX, maxY), (0, 0, 255),
2)
md.update(gray)
total += 1
with lock:
outputFrame = frame.copy()
def detect_motion(frameCount):
# grab global references to the video stream, output frame, and
# lock variables
global vs, outputFrame, lock, reportMode
# 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()
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
if reportMode:
data = {
'deviceId': 'Camera_CM1',
'title': 'Cảnh báo bất thường',
'body': 'Có người đột nhập',
}
res = requests.post(
'http://192.168.2.101:4000/api/v1/messaging/send-message', json=data)
reportMode = False
(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 detect_motion(frameCount):
# grab global references to the video stream, output frame, and
# lock variables
global vs, outputFrame, lock, cameraAction
# 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()
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
# 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)
# check 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
if cameraAction == 5:
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
#if cameraAction == 0: do nothing
if cameraAction == 1: #rotate left
frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
elif cameraAction == 2: #rotate right
frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
elif cameraAction == 3: #flip
frame = cv2.rotate(frame, cv2.ROTATE_180)
elif cameraAction == 4: #convert to greyscale
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# acquire the lock, set the output frame, and release the
# lock
with lock:
outputFrame = frame.copy()
def detect_motion(frameCount, prototxt, model):
# 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()
# frame = imutils.resize(frame, width=720)
# 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
frame = server.main(prototxt, model)
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 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 detect_motion(frameCount):
# grab global references to the video stream, output frame, and lock variables
global vs, outputFrame, lock, out
# 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()
# write stream to video clip and save to local drive:
out.write(frame)
# open window to show how the the client will see:
#cv2.imshow('(with menu)', frame)
#cv2.waitKey(1)
#out.write(frame)
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)
# check 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 detect_motion(frameCount):
global 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:
rpi_name, frame = image_hub.recv_image()
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()
image_hub.send_reply(b'OK')
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() frame = imutils.resize(frame, width=400) effect1.applyFilter(frame) total += 1 # acquire the lock, set the output frame, and release the # lock with lock: outputFrame = frame.copy()
def detect_motion(frameCount):
conn = sqlite3.connect('data/database.db')
conn.row_factory = dict_factory
curr = conn.cursor()
statusReset = "No"
curr.execute("UPDATE names SET status = 'No';")
conn.commit()
frame_number = 0
global cap, outputFrame, lock, data
md = SingleMotionDetector(accumWeight=0.1)
total = 0
print("[INFO] loading encodings + face detector...")
detector = cv2.CascadeClassifier(args["cascade"])
fps = FPS().start()
while True:
frame = vs.read()
frame = imutils.resize(frame, width=500)
gray = cv2.cvtColor(frame,
cv2.COLOR_BGR2GRAY) # face detection
rgb = cv2.cvtColor(frame,
cv2.COLOR_BGR2RGB) # face recognition
rects = detector.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags=cv2.CASCADE_SCALE_IMAGE)
boxes = [(y, x + w, y + h, x) for (x, y, w, h) in rects]
encodings = face_recognition.face_encodings(rgb, boxes)
names = []
for (top, right, bottom,
left), face_encoding in zip(boxes, encodings):
data = pickle.loads(open(args["encodings"], "rb").read())
matches = face_recognition.compare_faces(data["encodings"],
face_encoding,
tolerance=0.4)
face_distances = face_recognition.face_distance(
data["encodings"], face_encoding)
best_match_index = np.argmin(face_distances)
if matches[best_match_index]:
name = data["names"][best_match_index]
status = True
namaa = str(name)
check_if_data_exist = "SELECT * from names WHERE nameA='" + str(
name) + "';"
result = curr.execute(check_if_data_exist).fetchall()
if result[0]['status'] == "No":
name = result[0]['nameA']
position = result[0]['positionA']
dateTime = datetime.now()
dateSt = str(datetime.now())
status = "Found"
data = {
"id": result[0]['id'],
"nameA": name,
"positionA": position,
"status": status,
"dateTime": dateSt
}
update_sql = '''UPDATE names SET status = ?, dateTime = ? WHERE nameA = ? '''
curr.execute(update_sql, (status, dateSt, name))
conn.commit()
dateSt = str(datetime.now())
check_if_data_exist = "SELECT * from names WHERE nameA='" + str(
name) + "';"
result = curr.execute(check_if_data_exist).fetchall()
if result[0]['status'] == "Found":
name = result[0]['nameA']
position = result[0]['positionA']
dateTime = datetime.now()
dateSt = str(datetime.now())
status = "Found"
update_sql = '''UPDATE names SET status = ?, dateTime = ? WHERE nameA = ? '''
curr.execute(update_sql, (status, dateSt, name))
conn.commit()
dateSt = str(datetime.now())
check_if_data_exist = "SELECT id from names WHERE nameA='" + name + "';"
result = curr.execute(
check_if_data_exist).fetchall()
data = {
"id": result[0]['id'],
"nameA": name,
"positionA": position,
"status": status,
"dateTime": dateSt
}
cv2.rectangle(frame, (left, top), (right, bottom),
(255, 0, 0), 2)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(frame, name, (left + 6, bottom - 6), font,
0.5, (255, 255, 255), 1)
face_image = frame[top:bottom, left:right]
cv2.imwrite("person_found/" + name + '_Face.jpg',
face_image)
else:
cv2.rectangle(frame, (left, top), (right, bottom),
(0, 0, 255), 2)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(frame, "Unknown", (left + 6, bottom - 6),
font, 0.5, (255, 255, 255), 1)
timestamp = Hari.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 total > frameCount:
motion = md.detect(gray)
if motion is not None:
(thresh, (minX, minY, maxX, maxY)) = motion
md.update(gray)
total += 1
with lock:
outputFrame = frame.copy()
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
lineSpace = 30
# loop over frames from the video stream
while True:
start_time = time.time()
# read the next frame from the video stream, resize it,
# convert the frame to grayscale, and blur it
frame = vs.read()
frame = imutils.resize(frame, height=videoWidth, width=videoHeight)
#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)
#Framerate
cv2.putText(frame, str(int(1.0 / (time.time() - start_time))),
(screenMargin, frame.shape[0] - lineSpace),
cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 255, 0), 1)
#Resolution
cv2.putText(frame, str(frame.shape[0]),
(frame.shape[1] - 80, frame.shape[0] - lineSpace),
cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 255, 0), 1)
cv2.putText(frame, "x",
(frame.shape[1] - 65, frame.shape[1] - lineSpace),
cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 255, 0), 1)
cv2.putText(frame, str(frame.shape[1]),
(frame.shape[1] - 50, frame.shape[0] - lineSpace),
cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 255, 0), 1)
drawYPRH(frame, screenMargin, 2 * lineSpace)
#cv2.putText(frame, str(yprh[3]), (10, frame.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (onScreenColorR, onScreenColorG, onScreenColorB), 1)
drawCrosshair(frame, frame.shape[1], frame.shape[0])
#drawCompass(frame, frame.shape[1], frame.shape[0], int(round(float(yprh[3]))))
drawCompass(frame, frame.shape[1], frame.shape[0],
int(round(float(yprh[3]))))
# 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 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:
source = application.config['SOURCE']
application.logger.info(f"Reconnecting to: {source}")
vs2 = VideoStream(src=source).start()
time.sleep(0.25)
application.logger.info(f"Trying to read a frame from {source}...")
frame = vs2.read()
# still nothing falling back
if frame is None:
file = application.config['FALLBACK_SOURCE']
application.logger.warn(
f"Unable to connect to video source {source}! Falling back to streaming: {file}"
)
vs = FileVideoStream(file).start()
time.sleep(0.25)
application.logger.info(
f"Trying to read a frame from {file}...")
frame = vs.read()
else:
vs = vs2
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 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 this far
md = SingleMotionDetector(accumWeight=0.7)
total = 0
img_count = 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
# time str in one row
T = datetime.datetime.now()
print(' * ', T, end='\r', flush=True)
frame = vs.read()
frame = imutils.resize(frame, width=720)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 1)
# 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.45, (255, 255, 0), 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)
# check to see if motion was found
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),
(255, 255, 0), 1)
cv2.putText(frame, str('ALARM'), (30, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.65, (255, 255, 0), 2)
elif (keyboard.is_pressed('CTRL+s')):
# S key
img_name = "static/opencv_alarm_{}.jpg".format(img_count)
cv2.imwrite(filename=img_name, img=frame)
print("Motion Detected - Saved ")
img_new = cv2.imread('static/opencv_alarm_{}.jpg'.format(img_count))
cv2.imshow('Alarm Image', img_new)
cv2.waitKey(500)
img_count += 1
if img_count == 5:
img_count = 0
cv2.destroyAllWindows()
# update the background model and increment the total number
# of frames read this far
md.update(gray)
total += 1
# acquire the lock, set the output frame, and release the
# lock
with lock:
outputFrame = frame.copy()
def compute_frames():
global vs, outputFrame, output_frame_lock
global motion_active, motion_lock
global face_detection_active, face_detection_lock
global firebase_conf, firebase_utils, ts
motionCounter = 0
# initialize the motion detector and the total number of frames
# read thus far
md = SingleMotionDetector(accumWeight=0.1)
total = 0
lastUploaded = datetime.datetime.now()
# loop over frames from the video file stream
while True:
# grab the frame from the threaded video stream and resize it
# to 500px (to speedup processing)
frame = vs.read()
frame = imutils.resize(frame, width=500)
# FACE DETECTION FRAMES
# convert the input frame from (1) BGR to grayscale (for face
# detection) and (2) from BGR to RGB (for face recognition)
gray_face = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
rgb_face = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# MOTION DETECTION FRAME
gray_motion = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray_motion = cv2.GaussianBlur(gray_motion, (7, 7), 0)
# grab the current timestamp and draw it on the frame
timestamp = datetime.datetime.now()
ts = timestamp.strftime("%A %d %B %Y %I:%M:%S%p")
cv2.putText(frame, ts, (10, frame.shape[0] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 0, 255), 1)
## MOTION DETECTION STARTS
with motion_lock:
motion_status = motion_active
if motion_status == True:
# grab the current timestamp and draw it on the frame
timestamp = datetime.datetime.now()
text = "Unoccupied"
ts = timestamp.strftime("%A %d %B %Y %I:%M:%S%p")
cv2.putText(frame, ts, (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 > conf["frame_count"]:
# detect motion in the image
motion = md.detect(gray_motion, conf)
# cehck to see if motion was found in the frame
if motion is None:
text = "Unoccupied"
cv2.putText(frame, "Room Status: {}".format(text),
(10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(0, 0, 255), 2)
motionCounter = 0
else:
text = "Occupied"
# 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)
cv2.putText(frame, "Room Status: {}".format(text),
(10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(0, 0, 255), 2)
# Upload photo
# check to see if enough time has passed between uploads
if (timestamp - lastUploaded
).seconds >= conf["min_upload_seconds"]:
# increment the motion counter
motionCounter += 1
# check to see if the number of frames with consistent motion is
# high enough
if motionCounter >= conf["min_motion_frames"]:
# check to see if firebase sohuld be used
if firebase_conf["use_firebase"] == False:
firebase_conf = json.load(
"pyconf/firebase_conf.json")
if firebase_conf["use_firebase"]:
firebase_utils.upload(frame, ts)
# update the last uploaded timestamp and reset the motion
# counter
lastUploaded = timestamp
motionCounter = 0
# update the background model and increment the total number
# of frames read thus far
md.update(gray_motion)
total += 1
## MOTION DETECTION ENDS
## FACE DETECTION STARTS
with face_detection_lock:
face_detection_status = face_detection_active
if face_detection_status == True:
# put room status text
cv2.putText(frame, "Face detection active", (10, 20),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
# detect faces in the grayscale frame
rects = detector.detectMultiScale(gray_face,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags=cv2.CASCADE_SCALE_IMAGE)
# OpenCV returns bounding box coordinates in (x, y, w, h) order
# but we need them in (top, right, bottom, left) order, so we
# need to do a bit of reordering
boxes = [(y, x + w, y + h, x) for (x, y, w, h) in rects]
# compute the facial embeddings for each face bounding box
encodings = face_recognition.face_encodings(rgb_face, boxes)
names = []
known_face = False
# loop over the facial embeddings
for encoding in encodings:
# attempt to match each face in the input image to our known
# encodings
matches = face_recognition.compare_faces(
data["encodings"], encoding)
name = "Unknown"
# check to see if we have found a match
if True in matches:
known_face = True
# find the indexes of all matched faces then initialize a
# dictionary to count the total number of times each face
# was matched
matchedIdxs = [i for (i, b) in enumerate(matches) if b]
counts = {}
# loop over the matched indexes and maintain a count for
# each recognized face face
for i in matchedIdxs:
name = data["names"][i]
counts[name] = counts.get(name, 0) + 1
# determine the recognized face with the largest number
# of votes (note: in the event of an unlikely tie Python
# will select first entry in the dictionary)
name = max(counts, key=counts.get)
# check if there is a known face in the frame
# update the list of names
names.append(name)
# loop over the recognized faces
for ((top, right, bottom, left), name) in zip(boxes, names):
# draw the predicted face name on the image
cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0),
2)
y = top - 15 if top - 15 > 15 else top + 15
cv2.putText(frame, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,
0.75, (0, 255, 0), 2)
# upload photo
if (timestamp -
lastUploaded).seconds >= conf["min_upload_seconds"]:
# increment the motion counter
motionCounter += 1
if firebase_conf["use_firebase"] == False:
# Check if use_firebase condition is changed
firebase_conf = json.load("pyconf/firebase_conf.json")
if motionCounter >= conf["min_motion_frames"] and firebase_conf[
"use_firebase"] and boxes and not known_face:
# Upload image
firebase_utils.upload(frame, ts)
# Reset motion counter
motionCounter = 0
# Reset motion counter if no face detected
if not boxes:
motionCounter = 0
## FACE DETECTION ENDS
# STREAM OUTPUT
with output_frame_lock:
outputFrame = frame.copy()
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
# initialize KeyClipWriter, set counter for frames with no motion detected
kcw = KeyClipWriter()
consecFramesNoMotion = 0
# loop over frames from the video stream
while True:
timestamp = datetime.datetime.now()
text = "Unoccupied"
# read the next frame from the video stream, resize it,
# convert the frame to grayscale, and blur it
frame = vs.read()
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
# 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)
# check 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)
text = "Occupied"
# send email to notify user of motion
# send_email(timestamp)
# motion has occured, so reset frames with no motion counter
consecFramesNoMotion = 0
else:
consecFramesNoMotion += 1
record_video(kcw, frame, motion, consecFramesNoMotion, timestamp)
# grab the current timestamp and draw it on the frame
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)
cv2.putText(frame, "Room Status: {}".format(text), (10, 20),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (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 detect_hand(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
convert = {0: 'la', 1: 'dam', 2: 'keo'}
checkpoint = torch.load('MBN_epoch_1_loss_0.10.pth',
map_location=torch.device('cpu'))
# print(checkpoint)
model = MobileNetV2(num_classes=3)
model.load_state_dict(checkpoint)
# print(model)
model.eval()
# set robot and man score
robot = 0
man = 0
mapping = [22, 27, 17]
naming = ['paper', 'rock', 'scissors']
isEnd = 1
# 2 = scissors = GPIO17
# 1 = rock = GPIO27
# 0 = paper = GPIO22
# 17 keo 27 bua 22 la
# 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
# robot random
x = randint(0, 2)
frame = vs.read()
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:
image1 = preprocess_image(frame)
output = model(image1)
_, predicted = torch.max(output.data, 1)
print(convert[int(predicted)])
human = int(predicted)
cv2.putText(frame, convert[int(predicted)],
(10, frame.shape[0] - 30), cv2.FONT_HERSHEY_SIMPLEX,
0.35, (0, 0, 255), 1)
if human == 0 and isEnd == 1: # la
isEnd = 0
runUpServo(mapping[x])
if x == 0:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Draw')
elif x == 1:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Human win')
man += 1
else:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Robot win')
robot += 1
elif human == 2 and isEnd == 1: # keo
isEnd = 0
runUpServo(mapping[x])
if x == 0:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Human win')
man += 1
elif x == 1:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Robot win')
robot += 1
else:
print('Robot ' + naming[x] + ' x human ' + naming[human] +
' : Draw')
elif human == 1: # reset game
runDownServo()
isEnd = 1
print('Scoreboard Robot vs Human: %d : %d' % (robot, man))
# 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 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()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
face_locations = face_recognition.face_locations(frame)
face_landmarks_list = face_recognition.face_landmarks(
frame, face_locations, 'large')
# print(face_landmarks_list[0]['left_eye'])
red = [0, 0, 255]
if face_landmarks_list:
for (x, y) in face_landmarks_list[0]['left_eye']:
frame[y - 2:y + 2, x - 2:x + 2] = red
for (x, y) in face_landmarks_list[0]['right_eye']:
frame[y - 2:y + 2, x - 2:x + 2] = red
for (x, y) in face_landmarks_list[0]['left_eyebrow']:
frame[y - 2:y + 2, x - 2:x + 2] = red
for (x, y) in face_landmarks_list[0]['right_eyebrow']:
frame[y - 2:y + 2, x - 2:x + 2] = red
for (x, y) in face_landmarks_list[0]['nose_tip']:
frame[y - 2:y + 2, x - 2:x + 2] = red
for (x, y) in face_landmarks_list[0]['nose_bridge']:
frame[y - 2:y + 2, x - 2:x + 2] = red
for (x, y) in face_landmarks_list[0]['top_lip']:
frame[y - 2:y + 2, x - 2:x + 2] = red
for (x, y) in face_landmarks_list[0]['bottom_lip']:
frame[y - 2:y + 2, x - 2:x + 2] = red
for (x, y) in face_landmarks_list[0]['chin']:
frame[y - 2:y + 2, x - 2:x + 2] = red
#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 detect_motion(frameCount):
frame_number = 0
global cap, outputFrame, lock
storePlate = 0 # to count frame that already capture !!!
md = SingleMotionDetector(accumWeight=0.1)
total = 0
while True:
ret, gmbr = cap.read()
# cv2.imshow('VIDEO', gmbr)
gray = cv2.cvtColor(gmbr, cv2.COLOR_BGR2GRAY)
# noise removal with iterative bilateral filter(remove noise while preserving edges)
gray = cv2.bilateralFilter(gray, 11, 17, 17)
# cv2.imshow("2 - Bilateral Filter", gray)
plates = plate_cascade.detectMultiScale(gray, 1.3, 5)
# used for resizing the video
# img = cv2.resize(img, (640,480))
for (x,y,w,h) in plates:
cv2.rectangle(gmbr,(x,y),(x+w,y+h),(255,0,0),2)
plate_gray = gray[y:y+h, x:x+w] # gray plate
plate_color = gmbr[y:y+h, x:x+w] # colour plate
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(gmbr,'Plate',(x,y), font, 0.5, (11,255,255), 2, cv2.LINE_AA)
# cv2.imshow('Colour Plate',plate_color)
# time captured
dt = str(datetime.now())
print(dt)
# to store the grayscale image as a TEMPORARY file to apply the OCR
filename = "./captured/temp" + ".png"
cv2.imwrite(filename, plate_gray)
# load image, apply OCR
txt = pytesseract.image_to_string(Image.open(filename), lang = 'eng')
print(txt)
cv2.putText(gmbr, txt ,(x,y), font, 1, (11,255,255), 3, cv2.LINE_AA)
# here -> cara untuk baca image dari file and hntr ke pusher
for filename in glob.glob('captured/*.png'):
if ".png" in filename:
with open(filename,"rb") as f:
data = f.read()
# data['img'] = base64.encodebytes(img).decode("utf-8")
# image = json.dumps(data)
image = base64.b64encode(data)
create_database(image=data, txt=txt, masa=dt )
image = image.decode("utf-8")
print(image)
data = {"image": image, "txt": txt, "masa": dt}
pusher_client.trigger('Plate4', 'new-record', {'data': data})
# to display day, date and time on the video
timestamp = Day.datetime.now()
cv2.putText(gmbr, timestamp.strftime("%A %d %B %Y %I:%M:%S%p"), (10,gmbr.shape[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 0, 255), 1)
md.update(gray)
total += 1
with lock:
outputFrame = gmbr.copy()
def detect_motion(frameCount):
frame_number = 0
# grab global references to the video stream, output frame, and
# lock variables
global cap, 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()
# frame = imutils.resize(frame, width=400)
# gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# gray = cv2.GaussianBlur(gray, (7, 7), 0)
# ---------------------------------------------------
# ret, img = cap.read()
# small_frame = cv2.resize(img, (0, 0), fx=0.2, fy=0.2) # 1/5
# rgb_frame = small_frame[:, :, ::-1]
# face_locations = face_recognition.face_locations(rgb_frame)
# face_encodings = face_recognition.face_encodings(rgb_frame, face_locations)
# gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# gray = cv2.GaussianBlur(gray, (7, 7), 0)
# for face_encodings in face_encodings:
# match = face_recognition.compare_faces(known_faces, face_encodings, tolerance=0.90)
# name = None
# if match[0]:
# name = "Shafiq"
# cv2.imwrite( str(name) + '_muka.jpg', img)
# elif match[1]:
# name = "Hafizal"
# cv2.imwrite( str(name) + '_muka.jpg', img)
# elif match[2]:
# name = "Dalila"
# cv2.imwrite( str(name) + '_muka.jpg', img)
# elif match[3]:
# name = "Ayu"
# cv2.imwrite( str(name) + '_muka.jpg', img)
# elif match[4]:
# name = "Izzat"
# cv2.imwrite( str(name) + '_muka.jpg', img)
# elif match[5]:
# name = "Tinggy"
# cv2.imwrite( str(name) + '_muka.jpg', img)
# else:
# name = "Unknown"
# cv2.imwrite( str(name) + '_muka.jpg', img)
# face_names.append(name)
# for (top, right, bottom, left), name in zip(face_locations, face_names):
# top *= 5
# right *= 5
# bottom *= 5
# left *= 5
# # cv2.rectangle(img, (left, top), (right, bottom), (0, 0, 255), 2)
# # cv2.rectangle(img, (left, bottom - 25), (right, bottom), (0, 0, 255), cv2.FILLED)
# font = cv2.FONT_HERSHEY_DUPLEX
# cv2.putText(img, name, (left + 6, bottom - 6), font, 0.5, (255, 255, 255), 1)
#------------------------------------------------------------------------
ret, img = cap.read()
frame_number += 1
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
# rgb_frame = img[:, :, ::-1]
# face_locations = face_recognition.face_locations(rgb_frame)
# face_encodings = face_recognition.face_encodings(rgb_frame, face_locations)
cv2.circle(img, (960, 720), 10, (0, 0, 255), 2)
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
face_gray = gray[y:y + h, x:x + w]
face_color = img[y:y + h, x:x + w]
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img, 'Face', (x, y), font, 0.5, (11, 255, 255), 2,
cv2.LINE_AA)
eyes = eye_cascade.detectMultiScale(face_gray)
for (ex, ey, ew, eh) in eyes:
eyesC = cv2.rectangle(face_color, (ex, ey), (ex + ew, ey + eh),
(0, 255, 0), 2)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(eyesC, 'Eye', (ex, ey), font, 0.5, (11, 255, 255),
2, cv2.LINE_AA)
smiles = smileCascade.detectMultiScale(face_gray,
scaleFactor=1.7,
minNeighbors=3,
minSize=(15, 15))
for (ex, ey, ew, eh) in smiles:
smileC = cv2.rectangle(face_color, (ex, ey),
(ex + ew, ey + eh), (0, 255, 0), 1)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(smileC, 'Mouth', (ex, ey), font, 0.5,
(11, 255, 255), 2, cv2.LINE_AA)
nose = noseCascade.detectMultiScale(face_gray)
for (ex, ey, ew, eh) in nose:
noseC = cv2.rectangle(face_color, (ex, ey), (ex + ew, ey + eh),
(0, 255, 0), 2)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(noseC, 'Nose', (ex, ey), font, 0.5, (11, 255, 255),
2, cv2.LINE_AA)
#------------------------------------------------------------------------
timestamp = datetime.datetime.now()
cv2.putText(img, timestamp.strftime("%A %d %B %Y %I:%M:%S%p"),
(10, img.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35,
(0, 0, 255), 1)
if total > frameCount:
motion = md.detect(gray)
if motion is not None:
(thresh, (minX, minY, maxX, maxY)) = motion
cv2.rectangle(img, (minX, minY), (maxX, maxY), (0, 0, 255), 2)
md.update(gray)
total += 1
with lock:
outputFrame = img.copy()
def detect_motion(frameCount):
frame_number = 0
global cap, outputFrame, lock, data
md = SingleMotionDetector(accumWeight=0.1)
total = 0
print("[INFO] loading encodings")
detector = cv2.CascadeClassifier(args["cascade"])
fps = FPS().start()
while True:
data = pickle.loads(open(args["encodings"], "rb").read())
frame = vs.read()
frame = imutils.resize(frame, width=500)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # face detection
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # face recognition
rects = detector.detectMultiScale(gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags=cv2.CASCADE_SCALE_IMAGE)
boxes = [(y, x + w, y + h, x) for (x, y, w, h) in rects]
encodings = face_recognition.face_encodings(rgb, boxes)
names = []
for (top, right, bottom, left), face_encoding in zip(boxes, encodings):
matches = face_recognition.compare_faces(data["encodings"],
face_encoding,
tolerance=0.4)
face_distances = face_recognition.face_distance(
data["encodings"], face_encoding)
best_match_index = np.argmin(face_distances)
if matches[best_match_index]:
name = data["names"][best_match_index]
status = True
cv2.rectangle(frame, (left, top), (right, bottom), (255, 0, 0),
2)
# cv2.rectangle(img, (left, bottom - 25), (right, bottom), (0, 0, 255), cv2.FILLED)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(frame, name, (left + 6, bottom - 6), font, 0.5,
(255, 255, 255), 1)
face_image = frame[top:bottom, left:right]
cv2.imwrite("person_found/" + name + '_Face.jpg', face_image)
else:
cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255),
2)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(frame, "Unknown", (left + 6, bottom - 6), font,
0.5, (255, 255, 255), 1)
timestamp = Hari.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 total > frameCount:
motion = md.detect(gray)
if motion is not None:
(thresh, (minX, minY, maxX, maxY)) = motion
# cv2.rectangle(img, (minX, minY), (maxX, maxY),(0, 0, 255), 2)
md.update(gray)
total += 1
with lock:
outputFrame = frame.copy()
def detect_motion(frameCount):
# grab global references to the video stream, output frame, and
# lock variables
global vs, outputFrame, lock, socketio
# initialize the motion detector and the total number of frames
# read thus far
md = SingleMotionDetector(accumWeight=0.1)
total = 0
frameCnt = 0
word = ""
sentence = ""
pred_text = ' '
old_text = ' '
dup_time = 0
none_time = 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
if vs.read()[0] == False:
vs = cv2.VideoCapture(0)
vs.set(cv2.CAP_PROP_FPS, 30)
frame = vs.read()[1]
if frame.any() != None:
frameCnt = frameCnt + 1
frame = cv2.flip(frame, 1)
if frameCnt % 15 == 0:
pred_text = get_pred_from_contour(frame)
if pred_text != None and pred_text != 'NOTHING':
if old_text != pred_text: #and pred_text != 'Thank you!' and pred_text != 'Awesome!':
word = word + pred_text
old_text = pred_text
dup_time = 0
none_time = 0
socketio.emit('message', 'Symbol :' + pred_text)
elif old_text == pred_text:
dup_time = dup_time + 1
print("dup_time=" + str(dup_time))
elif pred_text == 'NOTHING':
none_time = none_time + 1
if pred_text == 'NOTHING' and none_time == 2:
correctWord = wordMatcher.correction(word)
old_text = ' '
word = word if correctWord is None else correctWord
if len(word.strip()) > 0:
socketio.emit('message', 'Word :' + word)
sentence = sentence + " " + word
word = ""
if pred_text == 'NOTHING' and none_time > 4:
sentence = sentence + " " + word
none_time = 0
word = ""
if len(sentence.strip()) > 0:
socketio.emit('pred', sentence)
sentence = ""
frameCnt = 0
#cv2.rectangle(frame, (x,y), (x+w, y+h), (0,0,0), 1)
#res = np.hstack((frame, blackboard))
res = frame
with lock:
outputFrame = res.copy()
ap.add_argument("-o", "--output", required=True, help="path to the output directory")
ap.add_argument("-m", "--min-frames", type=int, default=120,
help="minimum # of frames containing motion before writing to file")
ap.add_argument("-p", "--picamera", type=int, default=-1,
help="whether or not the Raspberry Pi camera should be used")
args = vars(ap.parse_args())
# initialize the video stream and allow the cammera sensor to warmup
print("[INFO] warming up camera...")
vs = VideoStream(usePiCamera=args["picamera"] > 0).start()
time.sleep(2.0)
# initialize the motion detector, the total number of frames read thus far, the
# number of consecutive frames that have contained motion, and the spatial
# dimensions of the frame
md = SingleMotionDetector(accumWeight=0.1)
total = 0
consec = None
frameShape = None
# loop over frames
while True:
# read the next frame from the video stream, resize it, convert the frame to
# grayscale, and blur it
frame = vs.read()
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()
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()
frame = imutils.resize(frame, width=400)
height, width, channels = frame.shape
blob = cv2.dnn.blobFromImage(frame,
0.00392, (416, 416), (0, 0, 0),
True,
crop=False)
net.setInput(blob)
outs = net.forward(output_layers)
# Showing informations on the screen
class_ids = []
confidences = []
boxes = []
for out in outs:
for detection in out:
scores = detection[5:]
class_id = np.argmax(scores)
confidence = scores[class_id]
if confidence > 0.2:
# Object detected
center_x = int(detection[0] * width)
center_y = int(detection[1] * height)
w = int(detection[2] * width)
h = int(detection[3] * height)
# Rectangle coordinates
x = int(center_x - w / 2)
y = int(center_y - h / 2)
boxes.append([x, y, w, h])
confidences.append(float(confidence))
class_ids.append(class_id)
indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.4, 0.3)
for i in range(len(boxes)):
if i in indexes:
x, y, w, h = boxes[i]
label = str(classes[class_ids[i]])
confidence = confidences[i]
color = colors[class_ids[i]]
cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
cv2.rectangle(frame, (x, y), (x + w, y + 30), color, -1)
cv2.putText(frame, label + " " + str(round(confidence, 2)),
(x, y + 30), font, 3, (255, 255, 255), 3)
elapsed_time = time.time() - starting_time
fps = frame_id / elapsed_time
cv2.putText(frame, "FPS: " + str(round(fps, 60)), (10, 50),
font, 3, (0, 0, 0), 3)
cv2.imshow("Image", frame)
key = cv2.waitKey(1)
if key == 27:
break
# acquire the lock, set the output frame, and release the
# lock
with lock:
outputFrame = frame.copy()
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
# render_template('1.html')
EYE_AR_THRESH = 0.25
EYE_AR_CONSEC_FRAMES = 30
# initialize the frame counter as well as a boolean used to
# indicate if the alarm is going off
COUNTER = 0
ALARM_ON = False
# initialize dlib's face detector (HOG-based) and then create
# the facial landmark predictor
print("[INFO] loading facial landmark predictor...")
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
# grab the indexes of the facial landmarks for the left and
# right eye, respectively
(lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
(rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
# start the video stream thread
print("[INFO] starting video stream thread...")
# 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()
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
rects = detector(gray, 0)
# loop over the face detections
for rect in rects:
# determine the facial landmarks for the face region, then
# convert the facial landmark (x, y)-coordinates to a NumPy
# array
shape = predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
# extract the left and right eye coordinates, then use the
# coordinates to compute the eye aspect ratio for both eyes
leftEye = shape[lStart:lEnd]
rightEye = shape[rStart:rEnd]
leftEAR = eye_aspect_ratio(leftEye)
rightEAR = eye_aspect_ratio(rightEye)
# average the eye aspect ratio together for both eyes
ear = (leftEAR + rightEAR) / 2.0
# compute the convex hull for the left and right eye, then
# visualize each of the eyes
leftEyeHull = cv2.convexHull(leftEye)
rightEyeHull = cv2.convexHull(rightEye)
cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)
cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)
# check to see if the eye aspect ratio is below the blink
# threshold, and if so, increment the blink frame counter
if ear < EYE_AR_THRESH:
COUNTER += 1
# if the eyes were closed for a sufficient number of
# then sound the alarm
if COUNTER >= EYE_AR_CONSEC_FRAMES:
# if the alarm is not on, turn it on
if not ALARM_ON:
ALARM_ON = True
# check to see if an alarm file was supplied,
# and if so, start a thread to have the alarm
# sound played in the background
if ('Alarm.mp3') != "":
t = Thread(target=sound_alarm(True),
args=(True))
t.deamon = True
t.start()
# draw an alarm on the frame
cv2.putText(frame, "DROWSINESS ALERT!", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
else:
sound_alarm(False)
# otherwise, the eye aspect ratio is not below the blink
# threshold, so reset the counter and alarm
else:
COUNTER = 0
ALARM_ON = False
# draw the computed eye aspect ratio on the frame to help
# with debugging and setting the correct eye aspect ratio
# thresholds and frame counters
cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
# 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()