class Video():
def __init__(self):
self.vs = VideoStream(usePiCamera=1 > 0).start()
time.sleep(2.0)
self.currentFrame = np.array([])
self.raw_img = np.array([])
def captureRawFrame(self):
"""
capture frame and reverse RBG BGR and return opencv image
"""
rawFrame = self.vs.read()
rawFrame = imutils.resize(rawFrame, width=640)
self.raw_img = rawFrame
#return rawFrame
def convertFrame(self):
"""
converts frame to format suitable for QtGui
"""
try:
self.currentFrame = cv2.cvtColor(self.raw_img, cv2.COLOR_BGR2RGB)
height, width = self.currentFrame.shape[:2]
img = QtGui.QImage(self.currentFrame,
width,
height,
QtGui.QImage.Format_RGB888)
img = QtGui.QPixmap.fromImage(img)
#self.previousFrame = self.currentFrame
img = img.scaledToHeight(480)
img = img.scaledToWidth(360)
return img
except:
return None
class recordVideo():
def __init__(self):
# initialize the video stream and allow the camera
# sensor to warmup
self.vs = VideoStream(usePiCamera=1 > 0).start()
time.sleep(2.0)
self.currentFrame = np.array([])
self.raw_img = np.array([])
self.writer = None
(h, w) = (None, None)
def captureRawFrame(self):
"""
capture frame and reverse RBG BGR and return opencv image, and also record the video
"""
rawFrame = self.vs.read()
rawFrame = imutils.resize(rawFrame, width=640)
self.raw_img = rawFrame
#return rawFrame
def initRecord(self):
if self.writer == None:
# store the image dimensions, initialzie the video writer,
# and construct the zeros array
#(h, w) = self.raw_img.shape[:2]
self.writer = cv2.VideoWriter('./demoVideo/'+str(int(time.time()))+'.avi', cv2.cv.FOURCC(*"XVID"), 15,
(640 , 480 ), True)
def record(self):
# write the output frame to file
self.writer.write(self.raw_img)
def convertFrame(self):
"""
converts frame to format suitable for QtGui
"""
try:
self.currentFrame = cv2.cvtColor(self.raw_img, cv2.COLOR_BGR2RGB)
height, width = self.currentFrame.shape[:2]
img = QtGui.QImage(self.currentFrame,
width,
height,
QtGui.QImage.Format_RGB888)
img = QtGui.QPixmap.fromImage(img)
#self.previousFrame = self.currentFrame
img = img.scaledToHeight(480)
img = img.scaledToWidth(360)
return img
except:
return None
def main():
global frame, key
# initialize the camera and grab a reference to the raw camera capture
wdth = int(math.floor(360))
hgth = int(math.floor(800))
camera = VideoStream(usePiCamera=True,resolution=(wdth,hgth)).start()
time.sleep(2.0)
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
writer = None
(h,w) = (None, None)
# setup the mouse callback
cv2.startWindowThread()
cv2.namedWindow("Detection")
cv2.setMouseCallback("Detection",mouseOn)
# keep looping over the frames
#for frame2 in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
while True:
frame = camera.read();
frame = cv2.transpose(frame);
frame = cv2.flip(frame,1)
timestamp = datetime.datetime.now()
ts = timestamp.strftime("%d/%m/%Y %H:%M:%S")
cv2.putText(frame,ts,(10,frame.shape[0]-10),cv2.FONT_HERSHEY_SIMPLEX,0.35,(0,255,0),1)
if writer is None:
(h,w) = frame.shape[:2]
writer = cv2.VideoWriter("/media/usb/test_" + timestamp.strftime("%d_%m_%Y_%H%M") + ".avi", fourcc,5,(w,h), True)
writer.write(frame)
cv2.imshow("Detection", frame);
#cv2.setMouseCallback("Detection",mouseOn)
#key = cv2.waitKey(10) & 0xFF
# if the 'q' key is pressed, stop the loop
if key == ord("q"): #cv2.EVENT_LBUTTONDOWN: #ord("q"):
# cv2.destroyAllWindows()
# camera.stop()
break
# cleanup the camera and close any open windows
cv2.destroyAllWindows()
camera.stop()
class TEVideoHandler:
def __init__(self):
self.FRAME_WIDTH = conf.DEF_FRAME_WIDTH
self.FRAME_HEIGHT = conf.DEF_FRAME_HEIGHT
# devices
self.video_file = None
self.camera = None
self.picamera = None
def set_frame_size(w, h):
if self.video_file is not None or self.camera is not None or self.picamera is not None:
raise TEVideoException("Frame size need to be set before initialization")
self.FRAME_WIDTH = w
self.FRAME_HEIGHT = h
def initialize_with_file(self, filename):
if self.video_file is not None or self.camera is not None or self.picamera is not None:
raise TEVideoException("Already Initialized")
self.video_file = cv2.VideoCapture(filename)
def initialize_with_configured_cam(self):
cam_selector = {
conf.CameraType.PYCAMERA: lambda: self.initialize_with_pycamera(),
conf.CameraType.PYCAMERA_ROBUST: lambda: self.initialize_with_pycamera2(),
conf.CameraType.WEBCAM: lambda: self.initialize_with_webcam(),
}
cam_selector[conf.CAMERA_TYPE]()
def initialize_with_pycamera(self):
if self.video_file is not None or self.camera is not None or self.picamera is not None:
raise TEVideoException("Already Initialized")
self.camera = VideoStream(usePiCamera=True).start()
time.sleep(2.0)
# It uses picamera library to disable auto control feature
def initialize_with_pycamera2(self):
if self.video_file is not None or self.camera is not None or self.picamera is not None:
raise TEVideoException("Already Initialized")
self.picamera = PiCamera()
self.picamera.resolution = (self.FRAME_WIDTH, self.FRAME_HEIGHT)
self.picamera.framerate = 30
self.rawCapture = PiRGBArray(self.picamera, size=(self.FRAME_WIDTH, self.FRAME_HEIGHT))
time.sleep(0.1)
self.picamera.shutter_speed = self.picamera.exposure_speed
self.picamera.exposure_mode = 'off'
g = self.picamera.awb_gains
self.picamera.awb_mode = 'off'
self.picamera.awb_gains = g
self.stream = self.picamera.capture_continuous(self.rawCapture, format="bgr", use_video_port=True)
# Tested with a monitor webcam, but didn't checked with the webcam macbook
def initialize_with_webcam(self):
if self.video_file is not None or self.camera is not None or self.picamera is not None:
raise TEVideoException("Already Initialized")
self.camera = VideoStream().start()
time.sleep(2.0)
# Read a frame
# Return: frame (pixel array)
# Note: if not grapped (for video file), raise exception
def read(self):
frame = None
if self.video_file is not None:
(grabbed, frame) = self.video_file.read()
if not grabbed:
raise TEInvalidFrameException()
elif self.camera is not None:
frame = self.camera.read()
elif self.picamera is not None:
data = self.stream.next()
frame = data.array
self.rawCapture.truncate(0)
# If still null frame,
if frame is None:
raise TEInvalidFrameException()
# resize the frame
frame = imutils.resize(frame, width=self.FRAME_WIDTH)
return frame
def release(self):
if self.video_file is not None:
self.video_file.release()
elif self.camera is not None:
# Pycamera may not have the release function
if hasattr(self.camera, 'release'):
self.camera.release()
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# initialize the video stream and allow the camera sensor to warm up
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
#initiate the video stream and allow camera to warm up
print("{INFO} starting video stream..")
vs = VideoStream(src=0).start()
time.sleep(2.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()
frame = imutils.resize(frame, width=600)
# grab the frame dimensions and convert it to a blob
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 1.0,
(300, 300), (104.0, 177.0, 123.0))
# 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 range(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with the
import time
import cv2
import imutils
from imutils.video import VideoStream
from matcher import Matcher
matcher = Matcher([("fau-logo", "./templates/fau-logo.png"),
("first-logo", "./templates/first-logo.jpg"),
("nextera-logo", "./templates/nextera-energy-logo.jpg"),
("techgarage-logo", "./templates/techgarage-logo.png")
], min_keypoints_pct_match=8)
cam = VideoStream(usePiCamera=False).start()
cnt = 0
while True:
img = cam.read()
cv2.imshow("Pic", img)
print matcher.match(img)
key = cv2.waitKey(10)
if key == ord('q'):
break
cam.stop()
cv2.destroyAllWindows()
def main():
# Definition of color tracking
#lower = [170, 240, 170]
#upper = [255, 255, 215]
# lower = [0, 0, 254]
# upper = [255, 10, 255]
lower = [0, 0, 0]
upper = [255, 110, 255]
kernel = np.ones((3, 3), np.uint8)
args = get_arguments()
state = True
x = 0
y_up = 0
y_down = 0
if args['webcam'] != -1:
camera = cv2.VideoCapture(0)
elif args['picamera'] != -1:
camera = VideoStream(usePiCamera=args['picamera'] > 0).start()
time.sleep(2.0)
elif args['query']:
# load the query image, compute the ratio of the old height to the new height, clone it, and resize it
image = cv2.imread(args['query'])
# image = imutils.resize(image, height=320)
while state:
if args['webcam'] != -1:
ret, image = camera.read()
if not ret:
break
elif args['picamera'] != -1:
image = camera.read()
cv2.imshow("Image", image)
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
height, width, color = image.shape
print(height, width, color)
# create NumPy arrays from the boundaries
lower = np.array(lower, dtype="uint8")
upper = np.array(upper, dtype="uint8")
# find the colors within the specified boundaries and apply
# the mask
thresh = cv2.inRange(hsv, lower, upper)
bitwise = cv2.bitwise_and(image, image, mask=thresh)
opening = cv2.morphologyEx(bitwise, cv2.MORPH_OPEN, kernel)
output = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel)
cv2.imshow("images", output)
for r in range(0, height - 1):
for c in range(0, width - 1):
if (output[r][c][0] >= 10):
x = c
y_up = r
break
if x is not 0:
break
for r in range(0, height - 1):
for c in range(x - 10, x + 10):
if (output[r][c][0] >= 10):
y_down = r
print(x, y_up, y_down, y_up - y_down)
cv2.circle(output, (int(x), int(y_up)), 10, (0, 0, 255), 2)
cv2.circle(output, (int(x), int(y_down)), 5, (0, 255, 255), 2)
cv2.imshow("result", output)
if cv2.waitKey(1) & 0xFF is ord('q'):
break
def Camera():
def detect_and_predict_mask(frame, faceNet, maskNet):
# grab the dimensions of the frame and then construct a blob
# from it
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300),
(104.0, 177.0, 123.0))
# pass the blob through the network and obtain the face detections
faceNet.setInput(blob)
detections = faceNet.forward()
# initialize our list of faces, their corresponding locations,
# and the list of predictions from our face mask network
faces = []
locs = []
preds = []
# loop over the detections
for i in range(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with
# the detection
confidence = detections[0, 0, i, 2]
# filter out weak detections by ensuring the confidence is
# greater than the minimum confidence
if confidence > args["confidence"]:
# compute the (x, y)-coordinates of the bounding box for
# the object
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
# ensure the bounding boxes fall within the dimensions of
# the frame
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))
# extract the face ROI, convert it from BGR to RGB channel
# ordering, resize it to 224x224, and preprocess it
face = frame[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
# add the face and bounding boxes to their respective
# lists
faces.append(face)
locs.append((startX, startY, endX, endY))
# only make a predictions if at least one face was detected
if len(faces) > 0:
# for faster inference we'll make batch predictions on *all*
# faces at the same time rather than one-by-one predictions
# in the above `for` loop
faces = np.array(faces, dtype="float32")
preds = maskNet.predict(faces, batch_size=32)
# return a 2-tuple of the face locations and their corresponding
# locations
return (locs, preds)
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-f",
"--face",
type=str,
default="face_detector",
help="path to face detector model directory")
ap.add_argument("-m",
"--model",
type=str,
default="mask_detector.model",
help="path to trained face mask detector model")
ap.add_argument("-c",
"--confidence",
type=float,
default=0.5,
help="minimum probability to filter weak detections")
args = vars(ap.parse_args())
# load our serialized face detector model from disk
print("[INFO] loading face detector model...")
prototxtPath = os.path.sep.join([args["face"], "deploy.prototxt"])
weightsPath = os.path.sep.join(
[args["face"], "res10_300x300_ssd_iter_140000.caffemodel"])
faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)
# load the face mask detector model from disk
print("[INFO] loading face mask detector model...")
maskNet = load_model(args["model"])
# initialize the video stream and allow the camera sensor to warm up
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.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()
frame = imutils.resize(frame, width=400)
# detect faces in the frame and determine if they are wearing a
# face mask or not
(locs, preds) = detect_and_predict_mask(frame, faceNet, maskNet)
# loop over the detected face locations and their corresponding
# locations
for (box, pred) in zip(locs, preds):
# unpack the bounding box and predictions
(startX, startY, endX, endY) = box
(mask, withoutMask) = pred
# determine the class label and color we'll use to draw
# the bounding box and text
label = "Mask" if mask > withoutMask else "No Mask"
color = (0, 255, 0) if label == "Mask" else (0, 0, 255)
# include the probability in the label
label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)
# display the label and bounding box rectangle on the output
# frame
cv2.putText(frame, label, (startX, startY - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
cv2.rectangle(frame, (startX, startY), (endX, endY), color, 2)
# show the output frame
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
# do a bit of cleanup
cv2.destroyAllWindows()
vs.stop()
redUpper1 = (10, 255, 255) redLower2 = (160, 100, 100) redUpper2 = (179, 255, 255) # initialize the list of tracked points, the frame counter, # and the coordinate deltas (dX, dY) = (0, 0) video_stream = VideoStream(usePiCamera=False, resolution=(640,480), framerate=32).start() time.sleep(2) # keep looping while True: # grab the current frame # image = video_stream.read() frame = video_stream.read() # resize the frame, blur it, and convert it to the HSV # color space # frame = imutils.resize(image, width=400) blurred = cv2.GaussianBlur(frame, (11, 11), 0) hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # construct a mask for the color "green", then perform # a series of dilations and erosions to remove any small # blobs left in the mask mask1 = cv2.inRange(hsv, redLower1, redUpper1) mask2 = cv2.inRange(hsv, redLower2, redUpper2) mask = mask1 + mask2 mask = cv2.erode(mask, None, iterations=2) mask = cv2.dilate(mask, None, iterations=2)
class VideoCamera(object):
def __init__(self, prototxt, model, confidence=0.2):
self.prototxt = prototxt
self.model = model
self.confidence = confidence
print("[INFO] loading model...")
self.net = cv2.dnn.readNetFromCaffe(self.prototxt, self.model)
# initialize the video stream, allow the cammera sensor to warmup,
# and initialize the FPS counter
print("[INFO] starting video stream...")
self.vs = VideoStream(src=0).start()
self.CLASSES = [
"background", "aeroplane", "bicycle", "bird", "boat", "bottle",
"bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse",
"motorbike", "person", "pottedplant", "sheep", "sofa", "train",
"tvmonitor"
]
self.COLORS = np.random.uniform(0, 255, size=(len(self.CLASSES), 3))
self.fps = FPS().start()
def __del__(self):
self.vs.stop()
self.fps.stop()
print("[INFO] elapsed time: {:.2f}".format(self.fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(self.fps.fps()))
def get_frame(self):
frame = self.vs.read()
frame = imutils.resize(frame, width=400)
(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
self.net.setInput(blob)
detections = self.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 > self.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(self.CLASSES[idx],
confidence * 100)
cv2.rectangle(frame, (startX, startY), (endX, endY),
self.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, self.COLORS[idx], 2)
# update the FPS counter
self.fps.update()
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
def mainvideosavecam():
j=1
dict={}
previds=[-1]
current_directory = os.getcwd()
final_directory = os.path.join(current_directory, r'frames_cam')
if not os.path.exists(final_directory):
os.makedirs(final_directory)
prototxtPath = os.path.sep.join(["face_detector", "deploy.prototxt"])
weightsPath = os.path.sep.join(["face_detector", "res10_300x300_ssd_iter_140000.caffemodel"])
faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)
maskNet = load_model(os.path.sep.join(["face_detector", "mask_detector2.h5"]))
vs = VideoStream(0).start()
time.sleep(2.0)
while True:
rects = []
frame = vs.read()
#frame = imutils.resize(frame, width=1080)
new = detect_and_predict_mask(frame, faceNet, maskNet)
now = datetime.now()
date_string = now.strftime("%d/%m/%Y")
time_string = now.strftime("%H:%M:%S")
for box in new:
(startX, startY, endX, endY) = box
#mask = pred[0][0]
#withoutmask = pred[0][1]
#label = "Mask" if mask > withoutmask else "No mask"
#color = (0, 255, 0) if label == "Mask" else (0, 0, 255)
#label = "{}: {:.2f}%".format(label, max(mask, withoutmask) * 100)
#cv2.putText(frame, label, (startX, startY - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
#cv2.rectangle(frame, (startX, startY), (endX, endY), (0,255,255), 2)
rects.append(box)
boundingboxes = np.array(rects)
boundingboxes = boundingboxes.astype(int)
rects = non_max_suppression_fast(boundingboxes, 0.3)
predictions=[]
faces=[]
ids=[]
objects = tracker.update(rects)
for (objectId, bbox) in objects.items():
ids.append(objectId)
for (objectId, bbox) in objects.items():
try:
x1, y1, x2, y2 = bbox
x1 = int(x1)
y1 = int(y1)
x2 = int(x2)
y2 = int(y2)
#print(previds)
#print(len(objects.items()))
face = frame[y1:y2, x1:x2]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
face = np.expand_dims(face, axis=0)
#faces.append(face)
pred = maskNet.predict(face)
#print(predictions)
mask = pred[0][0]
withoutmask = pred[0][1]
label = "Mask" if mask > withoutmask else "No mask"
color = (0, 255, 0) if label == "Mask" else (0, 0, 255)
label = "{}: {:.2f}%".format(label, max(mask, withoutmask) * 100)
cv2.putText(frame, label, (x1, y1 - 25), cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 0, 255), 2)
text = "ID: {}".format(objectId)
cv2.putText(frame, text, (x1, y1-5), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 1)
for id1 in ids:
k=0
l=0
for id2 in previds:
if id1 == id2:
break
elif id1 in previds:
k=1
elif id1>id2 and k==0:
#print(id1)
cv2.imwrite(os.path.join(final_directory,str(id1)+".jpg"), frame[startY:endY, startX:endX])
if j==1:
dict.update({'Number':[j], 'Date':date_string, 'Time':time_string, 'Label':label})
df = pd.DataFrame(dict)
df.to_csv(r'recordfile_videocam.csv', index=False)
else:
dict.update({'Number':[j], 'Date':date_string, 'Time':time_string, 'Label':label})
df = pd.DataFrame(dict)
df.to_csv(r'recordfile_videocam.csv',mode='a', header=False,index=False)
j+=1
previds.append(id1)
elif id2 in ids:
#print("yes")
l=1
elif l==0:
#print("yes")
previds.remove(id2)
for id1 in ids:
l=0
for id2 in previds:
if id2 in ids:
#print("yes")
l=1
elif l==0:
#print("yes")
previds.remove(id2)
except:
continue
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
cv2.destroyAllWindows()
vs.stop()
break
cv2.destroyAllWindows()
vs.stop()
#pcount= centroidtracker.peoplecount
# start the frames per second throughput estimator
fps = FPS().start()
# loop over frames from the video stream
while True:
# grab the next frame and handle if we are reading from either
# VideoCapture or VideoStream
frame = vs.read() # the vs contain the video by videocapture
frame = frame[1] if args.get("input", False) else frame # for capturing from webcam
pc()
# if we are viewing a video and we did not grab a frame then we
# have reached the end of the video
if args["input"] is not None and frame is None:
break
# resize the frame to have a maximum width of 500 pixels (the
# less data we have, the faster we can process it), then convert
# the frame from BGR to RGB for dlib
frame = imutils.resize(frame, width=500)
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# if the frame dimensions are empty, set them
class CoralMain:
def __init__(self):
"""
Initializations
"""
print("[INFO] Beginning initialization of Coral Main File")
# initialize the labels dictionary
self.labels = {}
self.labels[0] = "Can"
# Argument Parser for model path
ap = argparse.ArgumentParser()
ap.add_argument("-m", "--model", required=True,
help="path to TensorFlow Lite object detection model")
args = vars(ap.parse_args())
# load the Google Coral object detection model
print("[INFO] loading Coral model...")
self.model = DetectionEngine(args["model"])
# initialize the video stream and allow the camera sensor to warmup
self.vs = VideoStream(src=0).start()
time.sleep(2.0)
print("Finished Initialization of Model and Video")
# Socket Variables
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect(('192.168.1.230', 8485))
self.connection = self.client_socket.makefile('wb')
self.img_counter = 0
# Video Variables
self.encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90]
self.h = 480 # DO NOT CHANGE
self.w = 500 # DO NOT CHANGE
self.threshold = 0.6
def main_process(self):
"""
Main Process
:return: void
"""
# loop over the frames from the video stream
while True:
# grab the frame from the threaded video stream and resize it
frame = self.vs.read()
# to have a maximum width of 500 pixels
frame = imutils.resize(frame, width=500)
orig = frame.copy()
# prepare the frame for object detection by converting (1) it
# from BGR to RGB channel ordering and then (2) from a NumPy
# array to PIL image format
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# make predictions on the input frame
frame = Image.fromarray(frame)
results = self.model.detect_with_image(frame, threshold=self.threshold, keep_aspect_ratio=True,
relative_coord=False)
# Variable Init
largest_box = -999
largest_area = -999
centroid = None
# loop over the results
for r in results:
# extract the bounding box and box and predicted class label
box = r.bounding_box.flatten().astype("int")
(startX, startY, endX, endY) = box
area = (endY - startY) * (endX - startX)
# If this area is larger than any area before it make it the largest area
if area > largest_area:
largest_area = area
centroid = (int(startX + (endX - startX) / 2), int(startY + (endY - startY) / 2))
largest_box = (endX - startX) * (endY - startY)
label = self.labels[r.label_id]
# draw the bounding box and label on the image
cv2.rectangle(orig, (startX, startY), (endX, endY),
(0, 255, 0), 2)
y = startY - 15 if startY - 15 > 15 else startY + 15
text = "{}: {:.2f}%".format(label, r.score * 100)
cv2.putText(orig, text, (startX, y),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
# Add the centroid of the image and the centroid of the largest object
cv2.circle(orig, centroid, 4, (0, 255, 0), 2)
cv2.circle(orig, (int(self.w / 2), int(self.h / 2) - 20), 4, (0, 0, 255), 2)
if centroid is None:
centroid = (-99, -99)
# Socket Connection
self.socket_con(orig, centroid, largest_box)
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()
self.vs.stop()
def socket_con(self, frame, centroid, largest_box_size):
"""
Socket Connection
:param frame: the image frame
:param centroid: a tuple of the centroid
:param largest_box_size: the area of the largest detection
:return: void
"""
# Encode the image and pickle the frame and centroid into an array
result, frame = cv2.imencode('.jpg', frame, self.encode_param)
data = pickle.dumps((frame, centroid, largest_box_size), 0)
size = len(data)
# Send the image and data over the socket connection
print("{}: {}".format(self.img_counter, size))
self.client_socket.sendall(struct.pack(">L", size) + data)
self.img_counter += 1
face = preprocess_input(face)
roi.append(face)
location.append((x_start, y_start, x_end, y_end))
if len(roi) > 0:
roi = np.array(roi, dtype='float32')
prediction = trained_model.predict(roi, batch_size=32)
return (location, prediction)
while True:
frame = video.read()
frame = imutils.resize(frame, width=400)
(location, prediction) = detection_and_prediction(frame, weightpath,
protopath)
for (box, pred) in zip(location, prediction):
(x_start, y_start, x_end, y_end) = box
(mask, withoutmask) = pred
if mask > withoutmask:
label = 'Mask'
color = (0, 255, 0)
def calibration(usnm, mode):
# define three constants, one for the eye aspect ratio to indicate
# blink and then a set of constant for the number of consecutive upper limit and lower limit
# frames the eye must be below the threshold
name = usnm + "_" + mode
EYE_AR_THRESH = 0.19
EYE_AR_CONSEC_FRAMES_MIN = 3
EYE_AR_CONSEC_FRAMES_MAX = 32
# initialize the frame counters and the total number of blinks
COUNTER = 0
TOTAL = 0
# 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...")
vs = VideoStream(src=0)
vs.start()
time.sleep(1.0)
clsd = 0
frameno = 0
blink_data = []
start = time.time()
# loop over frames from the video stream
while True:
# grab the frame from the threaded video file stream, resize
# it, and convert it to grayscale
# channels)
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 = e_a_r(leftEye)
rightEAR = e_a_r(rightEye)
# average the eye aspect ratio together for both eyes
ear = (leftEAR + rightEAR) / 2.0
#blink_data.append([frameno, ear])
#frameno +=1
# 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
blink_data.append([frameno, ear, leftEAR, rightEAR, 0])
frameno += 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
blink_data.append([frameno, ear, leftEAR, rightEAR, 0])
if TOTAL == 0:
if COUNTER >= EYE_AR_CONSEC_FRAMES_MIN and COUNTER <= EYE_AR_CONSEC_FRAMES_MAX:
TOTAL = 1
for i in range(frameno - COUNTER, frameno, 1):
blink_data[i][-1] = 1
print("\n bLINK AT :", (frameno - COUNTER), " for:",
COUNTER, " frames\n")
#initialize a counter forinter blink rate afterdetecting first blink
IBT = 0
elif TOTAL > 0:
if COUNTER >= EYE_AR_CONSEC_FRAMES_MIN and COUNTER <= EYE_AR_CONSEC_FRAMES_MAX and IBT >= 2:
TOTAL += 1
for i in range(frameno - COUNTER, frameno, 1):
blink_data[i][-1] = 1
print("\n bLINK AT :", (frameno - COUNTER), " for:",
COUNTER, " frames\n")
elif COUNTER < EYE_AR_CONSEC_FRAMES_MIN and COUNTER > 0:
clsd = COUNTER
frm = (frameno) - COUNTER
blink_data[frameno - COUNTER][-1] = 0
print(" Not blink: {} , from frame: {}".format(
clsd, frm))
elif COUNTER == 0:
IBT += 1
else:
clsd = COUNTER
frm = (frameno) - COUNTER
for i in range((frameno - COUNTER), frameno, 1):
blink_data[(frameno) - i][-1] = 0
print(" Not blink: {} , from frame: {}".format(
clsd, frm))
frameno += 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), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
if mode == 't1':
cv2.putText(frame, " Blink type 1 Press 'q' after blinking",
(1, 310), cv2.FONT_HERSHEY_SIMPLEX, 0.3,
(0, 0, 255), 2)
elif mode == 't2':
cv2.putText(frame, " Blink type 2 Press 'q' after blinking ",
(1, 310), cv2.FONT_HERSHEY_SIMPLEX, 0.3,
(0, 0, 255), 2)
cv2.putText(frame, " sufficient number of times (at least 15) ",
(1, 330), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 255),
2)
# show the frame
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
name = name + '.pickle'
pickle.dump(blink_data, open(name, "wb"))
end = time.time()
#print("\n Total frames captured :", frameno-1," in:",end - start ," seconds\n")
break
# do a bit of cleanup
vs.stop()
cv2.destroyAllWindows()
svmtrnr(usnm, mode)
def call_cam():
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.models import load_model
from imutils.video import VideoStream
import numpy as np
import imutils
import time
import cv2
import os
import time
import sys
from tkinter import messagebox
import threading
def detect_and_predict_mask(frame, faceNet, maskNet):
# grab the dimensions of the frame and then construct a blob
# from it
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(frame, 1.0, (224, 224),
(104.0, 177.0, 123.0))
# pass the blob through the network and obtain the face detections
faceNet.setInput(blob)
detections = faceNet.forward()
# print(detections.shape)
# initialize our list of faces, their corresponding locations,
# and the list of predictions from our face mask network
faces = []
locs = []
preds = []
# loop over the detections
for i in range(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with
# the detection
confidence = detections[0, 0, i, 2]
# filter out weak detections by ensuring the confidence is
# greater than the minimum confidence
if confidence > 0.5:
# compute the (x, y)-coordinates of the bounding box for
# the object
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
# ensure the bounding boxes fall within the dimensions of
# the frame
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))
# extract the face ROI, convert it from BGR to RGB channel
# ordering, resize it to 224x224, and preprocess it
face = frame[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
# add the face and bounding boxes to their respective
# lists
faces.append(face)
locs.append((startX, startY, endX, endY))
# only make a predictions if at least one face was detected
if len(faces) > 0:
# for faster inference we'll make batch predictions on *all*
# faces at the same time rather than one-by-one predictions
# in the above `for` loop
faces = np.array(faces, dtype="float32")
preds = maskNet.predict(faces, batch_size=32)
# return a 2-tuple of the face locations and their corresponding
# locations
return (locs, preds)
# load our serialized face detector model from disk
prototxtPath = r"D:\Face-Mask-Detection-master\Face-Mask-Detection-master\face_detector\deploy.prototxt"
weightsPath = r"D:\Face-Mask-Detection-master\Face-Mask-Detection-master\face_detector\res10_300x300_ssd_iter_140000.caffemodel"
faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)
# load the face mask detector model from disk
maskNet = load_model(r"D:\Face-Mask-Detection-master\Face-Mask-Detection-master\mask_detector.model")
# initialize the video stream
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
# loop over the frames from the video stream
t1 = time.time() # this t1 is used to calculate 4 seconds since the camera was ON
mask_list = [] # this empty list will be used to calculate the average of Wearing Mask
while True:
# grab the frame from the threaded video stream and resize it
# to have a maximum width of 400 pixels
frame = vs.read()
frame = imutils.resize(frame, width=400)
# detect faces in the frame and determine if they are wearing a
# face mask or not
(locs, preds) = detect_and_predict_mask(frame, faceNet, maskNet)
# loop over the detected face locations and their corresponding
# locations
for (box, pred) in zip(locs, preds):
# unpack the bounding box and predictions
(startX, startY, endX, endY) = box
(mask, withoutMask) = pred
# determine the class label and color we'll use qto draw
# the bounding box and text
label = "Mask" if mask > withoutMask else "No Mask"
color = (0, 255, 0) if label == "Mask" else (0, 0, 255)
# include the probability in the label
label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)
mask_list.append(mask)
if time.time() - t1 > 4: # when 4 seconds passes
mask_avg = sum(mask_list) / len(mask_list)
if mask_avg*100 > 90: # when the average of wearing a mask is > 90%
messagebox.showinfo('Welcome', 'Welcome to the building, Thank you for wearing your mask')
exit() # after welcoming the employee close the program
else :
messagebox.showinfo('WAER IT !','Wear your MASK !!')
exit() # after alerting the employee, close the program so he can try again after wearing tha mask
# display the label and bounding box rectangle on the output
# frame
cv2.putText(frame, label, (startX, startY - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
cv2.rectangle(frame, (startX, startY), (endX, endY), color, 2)
# show the output frame
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
# do a bit of cleanup
cv2.destroyAllWindows()
vs.stop()
def main():
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
args = build_argparser().parse_args()
model_xml = args.model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
# Plugin initialization for specified device and load extensions library if specified
log.info("Initializing plugin for {} device...".format(args.device))
plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
if args.cpu_extension and 'CPU' in args.device:
plugin.add_cpu_extension(args.cpu_extension)
# Read IR
log.info("Reading IR...")
net = IENetwork(model=model_xml, weights=model_bin)
if plugin.device == "CPU":
supported_layers = plugin.get_supported_layers(net)
not_supported_layers = [
l for l in net.layers.keys() if l not in supported_layers
]
if len(not_supported_layers) != 0:
log.error(
"Following layers are not supported by the plugin for specified device {}:\n {}"
.format(plugin.device, ', '.join(not_supported_layers)))
log.error(
"Please try to specify cpu extensions library path in demo's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(
net.inputs.keys()) == 1, "Demo supports only single input topologies"
assert len(net.outputs) == 1, "Demo supports only single output topologies"
input_blob = next(iter(net.inputs))
out_blob = next(iter(net.outputs))
log.info("Loading IR to the plugin...")
exec_net = plugin.load(network=net, num_requests=2)
# Read and pre-process input image
n, c, h, w = net.inputs[input_blob].shape
del net
cap = None
if args.input == 'cam':
input_stream = 0
cap = VideoStream().start()
elif args.input == 'picam':
cap = VideoStream(usePiCamera=True, resolution=(640, 480)).start()
time.sleep(2)
else:
input_stream = args.input
assert os.path.isfile(args.input), "Specified input file doesn't exist"
cap = VideoStream(src=input_stream).start()
if args.labels:
with open(args.labels, 'r') as f:
labels_map = [x.strip() for x in f]
else:
labels_map = None
cur_request_id = 0
next_request_id = 1
log.info("Starting inference in async mode...")
log.info("To switch between sync and async modes press Tab button")
log.info("To stop the demo execution press Esc button")
is_async_mode = False
render_time = 0
frame = cap.read()
starttime = 0
while frame is not None:
if is_async_mode:
next_frame = cap.read()
original = next_frame.copy()
else:
frame = cap.read()
original = frame.copy()
initial_h, initial_w, depth = frame.shape
# Main sync point:
# in the truly Async mode we start the NEXT infer request, while waiting for the CURRENT to complete
# in the regular mode we start the CURRENT request and immediately wait for it's completion
inf_start = time.time()
if is_async_mode:
in_frame = cv2.resize(next_frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
exec_net.start_async(request_id=next_request_id,
inputs={input_blob: in_frame})
else:
in_frame = cv2.resize(frame, (w, h))
in_frame = in_frame.transpose(
(2, 0, 1)) # Change data layout from HWC to CHW
in_frame = in_frame.reshape((n, c, h, w))
exec_net.start_async(request_id=cur_request_id,
inputs={input_blob: in_frame})
if exec_net.requests[cur_request_id].wait(-1) == 0:
inf_end = time.time()
det_time = inf_end - inf_start
# Parse detection results of the current request
res = exec_net.requests[cur_request_id].outputs[out_blob]
objlist = []
for obj in res[0][0]:
# Draw only objects when probability more than specified threshold
if obj[2] > args.prob_threshold:
xmin = int(obj[3] * initial_w)
ymin = int(obj[4] * initial_h)
xmax = int(obj[5] * initial_w)
ymax = int(obj[6] * initial_h)
class_id = int(obj[1])
# Draw box and label\class_id
color = (min((7 - class_id) * 12.5,
255), min((7 - class_id) * 7,
255), min((7 - class_id) * 5, 255))
cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2)
det_label = labels_map[class_id] if labels_map else str(
class_id)
cv2.putText(
frame,
det_label + ' ' + str(round(obj[2] * 100, 1)) + ' %',
(xmin, ymin - 7), cv2.FONT_HERSHEY_COMPLEX, 0.6, color,
1)
objlist.append(det_label)
if len(objlist) > 0:
if (time.time() - starttime) > 10:
starttime = time.time()
timestamp = '{:%y-%m-%d_H_%M_%S}'.format(
datetime.datetime.now())
items = ['spoon', 'knife', 'fork', 'plate', 'cup', 'food']
outname = ""
for item in items:
if item in objlist:
outname = item
break
filename = outname + '_' + timestamp + '.jpg'
cv2.imwrite(filename, original)
# Draw performance stats
inf_time_message = "Inference time: N\A for async mode" if is_async_mode else \
"Inference time: {:.3f} ms".format(det_time * 1000)
render_time_message = "OpenCV rendering time: {:.3f} ms".format(
render_time * 1000)
async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id) if is_async_mode else \
"Async mode is off. Processing request {}".format(cur_request_id)
cv2.putText(frame, inf_time_message, (15, 15),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
cv2.putText(frame, render_time_message, (15, 30),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
cv2.putText(frame, async_mode_message, (10, int(initial_h - 20)),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
#
render_start = time.time()
cv2.imshow("Detection Results", frame)
render_end = time.time()
render_time = render_end - render_start
if is_async_mode:
cur_request_id, next_request_id = next_request_id, cur_request_id
frame = next_frame
key = cv2.waitKey(1)
if key == 27:
break
if (9 == key):
is_async_mode = not is_async_mode
log.info("Switched to {} mode".format(
"async" if is_async_mode else "sync"))
cv2.destroyAllWindows()
del exec_net
del plugin
class DualCamera():
def __init__(self):
self.root = Tk()
self.root.wm_title("Dual Cam")
self.saving = False
self.frames = []
self.overlay = False
self.image_left = ImageTk.PhotoImage(image=Image.fromarray(np.uint8(np.zeros((256, 256)))))
self.image_panel_left = Label(self.root, image = self.image_left)
self.image_panel_left.grid(row = 0, column = 0, columnspan=2)
self.image_right = ImageTk.PhotoImage(image=Image.fromarray(np.uint8(256 * np.random.rand(256, 256))))
self.image_panel_right = Label(self.root, image = self.image_right)
self.image_panel_right.grid(row = 0, column = 2, columnspan=2)
self.save_button = Button(width = 10, height = 2, text = 'Save', command=self.save)
self.save_button.grid(row = 1, column = 0)
self.calibrate_button = Button(width = 10, height = 2, text = 'Calibrate', command=self.calibrate)
self.calibrate_button.grid(row = 1, column = 1)
self.close_button = Button(width = 10, height = 2, text = 'Close', command=self.quit)
self.close_button.grid(row = 1, column = 3)
self.overlay_button = Button(width=10, height=2, text='Overlay', command=self.toggle_overlay)
self.overlay_button.grid(row = 1, column = 2)
self.bias_slider = Scale(self.root, from_=0, to=31, length=400, orient=HORIZONTAL, command=self.bias)
self.bias_slider.grid(row = 2, column = 1, columnspan=3)
self.bias_label = Label(self.root, text="Bias current")
self.bias_label.grid(row=2, column=0)
self.clock_slider = Scale(self.root, from_=0, to=63, length=400, orient=HORIZONTAL, command=self.clock)
self.clock_slider.grid(row = 3, column = 1, columnspan=3)
self.clock_label = Label(self.root, text="Clock speed")
self.clock_label.grid(row=3, column=0)
self.cm_slider = Scale(self.root, from_=0, to=31, length=400, orient=HORIZONTAL, command=self.cm)
self.cm_slider.grid(row = 4, column = 1, columnspan=3)
self.cm_label = Label(self.root, text="CM current")
self.cm_label.grid(row=4, column=0)
# set default positions
self.cm_slider.set(0x0C)
self.clock_slider.set(0x15)
self.bias_slider.set(0x05)
# initialize visible camera
self.vs = VideoStream(usePiCamera=True).start()
# thread for reading from sensor hardware intro an image queue
self.ir_images = Queue.LifoQueue()
self.ir_commands = Queue.Queue()
self.ir_calibrate = threading.Event()
self.ir_stop = threading.Event()
self.raw_ir_images = Queue.LifoQueue()
self.capture_thread = threading.Thread(
target=ir_capture,
name="capture_thread",
args=[self.ir_images, self.ir_calibrate, self.ir_stop, self.ir_commands, self.raw_ir_images]
)
self.capture_thread.start()
self.ticktock()
self.root.mainloop()
def ticktock(self):
# grab an image from the camera
frame = self.vs.read()
changed = False
if frame is not None:
frame = imutils.resize(frame, height=240)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
self.last_vis_frame = frame
image = Image.fromarray(frame)
if not self.overlay:
self.image_right = ImageTk.PhotoImage(image=image)
self.image_panel_right.configure(image=self.image_right);
changed = True
if not self.ir_images.empty():
ir_frame = self.ir_images.get()
if not self.ir_images.empty():
with self.ir_images.mutex:
self.ir_images.queue = []
ir_image = imutils.resize(ir_frame, height=240, inter=cv2.INTER_LINEAR)
ir_image = np.dstack((ir_image, ir_image, ir_image))
ir_image = cv2.LUT(ir_image, colormap).astype('uint8')
self.last_ir_frame = ir_image
self.image_left = ImageTk.PhotoImage(image=Image.fromarray(ir_image))
self.image_panel_left.configure(image=self.image_left)
changed = True
if changed and self.overlay:
overlay_image = np.zeros_like(self.last_vis_frame)
overlay_image[:,:,2] = 0.125 * self.last_vis_frame[:,:,0] + 0.25 * self.last_vis_frame[:,:,1] + 0.125 * self.last_vis_frame[:,:,2]
converted_frame = cv2.cvtColor(self.last_ir_frame, cv2.COLOR_RGB2HSV)
overlay_image[:,40:280,2] += 0.5 * converted_frame[:,:,2]
overlay_image[:,40:280,1] = converted_frame[:,:,1]
overlay_image[:,40:280,0] = converted_frame[:,:,0]
overlay_image = cv2.cvtColor(overlay_image, cv2.COLOR_HSV2RGB)
self.image_right = ImageTk.PhotoImage(image=Image.fromarray(overlay_image))
self.image_panel_right.configure(image=self.image_right)
if self.saving:
if not self.raw_ir_images.empty():
ir_frame = self.raw_ir_images.get()
if not self.raw_ir_images.empty():
with self.raw_ir_images.mutex:
self.raw_ir_images.queue = []
else:
ir_frame = None
self.frames.append((frame, ir_frame))
if not self.ir_calibrate.isSet():
self.calibrate_button.configure(text = 'Calibrate', command=self.calibrate, state="normal")
self.root.after(100, self.ticktock)
def quit(self):
self.vs.stop()
self.ir_stop.set()
self.root.quit()
def save(self):
self.save_button.configure(text = 'Stop Saving', command=self.stop_save)
self.saving = True
self.frames = []
def stop_save(self):
self.save_button.configure(text = 'Save', command=self.save)
now = time.strftime("%Y-%m-%dT%H:%M:%S")
pickle.dump(self.frames, open(now + ".p", "wb"))
self.frames = []
def calibrate(self):
self.calibrate_button.configure(text = 'Calibrating...', state="disabled")
self.ir_calibrate.set()
def cm(self, val):
val = int(val)
self.ir_commands.put(('cm', val))
def bias(self, val):
val = int(val)
self.ir_commands.put(('bias', val))
def clock(self, val):
val = int(val)
self.ir_commands.put(('clock', val))
def toggle_overlay(self):
if self.overlay:
self.overlay = False
self.overlay_button.configure(text = 'Overlay')
else:
self.overlay = True
self.overlay_button.configure(text = 'No Overlay')
def facial_recognise(self):
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-e",
"--encodings",
default="encodings.pickle",
help="path to serialized db of facial encodings")
ap.add_argument("-r",
"--resolution",
type=int,
default=240,
help="Resolution of the video feed")
ap.add_argument(
"-d",
"--detection-method",
type=str,
default="hog",
help="face detection model to use: either `hog` or `cnn`")
args = vars(ap.parse_args())
# load the known faces and embeddings
print("[INFO] loading encodings...")
data = pickle.loads(open(args["encodings"], "rb").read())
# initialize the video stream and then allow the camera sensor to warm up
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
# loop over frames from the video file stream
while True:
# grab the frame from the threaded video stream
frame = vs.read()
# convert the input frame from BGR to RGB then resize it to have
# a width of 750px (to speedup processing)
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
rgb = imutils.resize(frame, width=args["resolution"])
# detect the (x, y)-coordinates of the bounding boxes
# corresponding to each face in the input frame, then compute
# the facial embeddings for each face
boxes = face_recognition.face_locations(
rgb, model=args["detection_method"])
encodings = face_recognition.face_encodings(rgb, boxes)
names = []
# 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:
# 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)
# update the list of names
names.append(name)
# loop over the recognized faces
for name in names:
# print to console, identified person
print("Person found: {}".format(name))
email = name
# Set a flag to sleep the cam for fixed time
break
return email
# do a bit of cleanup
vs.stop()
y_offset2 = 250 x_offset2 = 300 y_offset3 = 250 x_offset3 = 0 y_offset4 = 700 x_offset4 = 50 imageCanvas = np.zeros((height, width, channels), np.uint8) Stream0 = VideoStream(3).start() Stream1 = VideoStream(1).start() Stream2 = VideoStream(2).start() Stream3 = VideoStream(4).start() time.sleep(2.0) streamL = Stream0.read() streamF = Stream1.read() streamR = Stream2.read() streamB = Stream3.read() streamL = imutils.resize(streamL, width=400) streamF = imutils.resize(streamF, width=400) streamR = imutils.resize(streamR, width=400) streamB = imutils.resize(streamB, width=400) screenCntL = find_points(streamL) screenCntF = find_points(streamF) screenCntR = find_points(streamR) screenCntB = find_points(streamB) ML = four_point_transform(streamL, screenCntL.reshape(4, 2))
# Set initial frame size.
frameSize = (1020, 720)
# Setup video stream
vs = VideoStream(src=0,
usePiCamera=PiCamera,
resolution=frameSize,
framerate=32).start()
# Allow camera to setup.
time.sleep(2.0)
i = 0
while 1:
# Read Video steram
img = vs.read()
# Convert frame into grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Find faces in frame
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
if len(faces) == 0:
# render a message on frame with no face detected
cv2.putText(img, "NO FACE DETECTED", (340, 40),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 4, cv2.LINE_AA)
else:
# render a message on frame with face detected
cv2.putText(img, "FACE DETECTED", (340, 40), cv2.FONT_HERSHEY_SIMPLEX,
1, (0, 255, 0), 4, cv2.LINE_AA)
for (x, y, w, h) in faces:
# Draw rectangle around every detected face
print("[INFO] starting cameras...")
leftStream = VideoStream(src=1).start()
#rightStream = VideoStream(usePiCamera=True).start()
rightStream = VideoStream(src=0).start()
time.sleep(2.0)
# initialize the image stitcher, motion detector, and total
# number of frames read
stitcher = Stitcher()
motion = BasicMotionDetector(minArea=500)
total = 0
# loop over frames from the video streams
while True:
# grab the frames from their respective video streams
left = leftStream.read()
right = rightStream.read()
# resize the frames
left = imutils.resize(left, width=400)
right = imutils.resize(right, width=400)
# stitch the frames together to form the panorama
# IMPORTANT: you might have to change this line of code
# depending on how your cameras are oriented; frames
# should be supplied in left-to-right order
result = stitcher.stitch([left, right])
# no homograpy could be computed
if result is None:
print("[INFO] homography could not be computed")
except:
write_to_log("Log.txt", objCnt)
def reset_cnt():
global objCnt
objCnt = 0
return objCnt
default_scheduler.every(args["f"]).seconds.do(check)
default_scheduler.every(args["f"]).seconds.do(reset_cnt)
print("Starting...")
while True:
frame = camera.read() # read camera
if frame is None:
print('fail with camera. Is it being used? src # correct?')
break
frame = imutils.resize(frame, width=400) # resize frame
height = np.size(frame, 0) # calculates the height of frame
width = np.size(frame, 1) # calculates the width of frame
blurred = cv2.GaussianBlur(frame, (21, 21), 0) # blurring image before hsv applied (less noise)
hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV) # creating hsv from blurred frame and converting the bgr to hsv
mask = cv2.inRange(hsv, np.array(args["a"]), np.array(args["b"])) # mask is setting hsv in range of the lower and upper HSV values
mask = cv2.dilate(mask, None, iterations=2) # dilate is opposite of erosion "thickens" image
mask = cv2.erode(mask, None, iterations=2) # erode "thins" image. erosion followed by dilation to remove white noises
res = cv2.bitwise_and(frame, frame, mask=mask) # this makes the color filter show that color in the res frame
def recognise(self):
"""
Starts Video stream and checks detected face againist encoded data
to recognise user through face.
:return: The reognised user's username
:rtype: str
"""
data = pickle.loads(open("encodings.pickle", "rb").read())
print("starting video stream...")
# initialize the video stream and allow the camera sensor to warm up
vs = VideoStream(src=0).start()
time.sleep(2.0)
# grab the frame from the threaded video stream
frame = vs.read()
# convert the input frame from BGR to RGB then resize it to have
# a width of 750px (to speedup processing)
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
rgb = imutils.resize(frame, width=240)
# detect the (x, y)-coordinates of the bounding boxes
# corresponding to each face in the input frame, then compute
# the facial embeddings for each face
boxes = face_recognition.face_locations(rgb, model="hog")
encodings = face_recognition.face_encodings(rgb, boxes)
names = []
# 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"
if True in matches:
# 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 = {}
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)
names.append(name)
for name in names:
vs.stop()
return(name)
vs.stop()
return ""
totalDown = 0
totalUp = 0
countlogU = 0
countlogD = 0
outFrames = totalFrames
fracao = 4
# Inicia os frames por segundo durante a estimativa.
fps = FPS().start()
# Loop sobre os frames do fluxo de arquivos de vídeo.
while True:
# Pega o próximo frame e manipula se estamos lendo o VideoCapture
# ou VideoStream
frame = stream.read()
frame = frame[1] if configure.get("input", False) else frame
# Se o frame não for pego, então nós temos alcançado o final do
# fluxo.
if configure["input"] is not None and frame is None:
break
# Pega a referência para o tensor da imagem de entrada e o tensor
# de caixas (boxes)
# OBS: Essas referências nos permitirão acessar seus valores
# associados depois de passar a imagem pela rede.
imageTensor = model.get_tensor_by_name("image_tensor:0")
boxesTensor = model.get_tensor_by_name("detection_boxes:0")
# Para cada caixa delimitadora nós gostaríamos de saber a pontuação
def lancerapp(x):
def eye_aspect_ratio(eye):
# compute the euclidean distances between the two sets of
# vertical eye landmarks (x, y)-coordinates
A = dist.euclidean(eye[1], eye[5])
B = dist.euclidean(eye[2], eye[5])
# compute the euclidean distance between the horizon
# eye landmark (x, y)-coordinates
C = dist.euclidean(eye[0], eye[3])
# compute the eye aspect ratio
ear = (A + B) / (2.0 * C)
# return the eye aspect ratio
return ear
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-w",
"--webcam",
type=int,
default=0,
help="index of webcam on system")
args = vars(ap.parse_args())
# define two constants, one for the eye aspect ratio to indicate
# blink and then a second constant for the number of consecutive
# frames the eye must be below the threshold for to set off the
# alarm
#Si on est dans un situaion ou il faut etre tres vigilant on peut rendre la deuxieme constante plus petite
EYE_AR_THRESH = 0.3
EYE_AR_CONSEC_FRAMES = x
#EYE_AR_CONSEC_FRAMES = 48
# initialize the frame counter as well as a boolean used to
# indicate if the alarm is going off
COUNTER = 0
# 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("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...")
vs = VideoStream(src=args["webcam"]).start()
time.sleep(1.0)
# loop over frames from the video stream
while True:
# grab the frame from the threaded video file stream, resize
# it, and convert it to grayscale
# channels)
#On passe en gris pour mieux detecter les contrastes
frame = vs.read()
frame = imutils.resize(frame, width=700)
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, (182, 196, 46), 1)
cv2.drawContours(frame, [rightEyeHull], -1, (182, 196, 46), 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
# draw an alarm on the frame
cv2.putText(frame, "Signes de somnolence!", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (54, 29, 231),
2)
#Lancer une autre application !
# otherwise, the eye aspect ratio is not below the blink
# threshold, so reset the counter and alarm
else:
COUNTER = 0
# 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, "Rapport d'ouverture: {:.2f}".format(ear),
(400, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(182, 196, 46), 2)
# show the frame
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
# do a bit of cleanup
cv2.destroyAllWindows()
vs.stop()
face_net = cv2.dnn.readNet(proto_txt_path, weights_path)
# подгрузка модели
mask_net = load_model("mask_detector.model")
# инициализация потока видео
logger.info("starting video stream...")
#rtsp_url = "rtsp://name:password/video"
# vs = VideoStream(rtsp_url).start()
# для взятие потока с ip-камеры
vs = VideoStream(src=0).start()
# циклю при рабочем потоке видео
while True:
# захват видео с потока и ресайз до максимальных 400 пикселей
frame = imutils.resize(vs.read(), width=400)
# определение лиц на видеопотоке и определение есть ли на них маска
try:
locs, preds = detect_and_predict_mask(frame, face_net,
mask_net) # падает
for box, pred in zip(locs, preds):
# распаковка ограничивающей рамке и прогнозов
startX, startY, endX, endY = box
mask, withoutMask = pred
# определение лейбла и цвета для отрисовки ограничевающих рамок
label, color = ("In mask", (
0, 255, 0)) if mask > withoutMask else ("Without mask",
(0, 0, 255))
import cv2
import numpy as np
from imutils.video import VideoStream
cam = VideoStream(src=0).start()
while (True):
img = cam.read()
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
red_lower = np.array([136, 87, 111], np.uint8)
red_upper = np.array([180, 255, 255], np.uint8)
blue_lower = np.array([99, 115, 150], np.uint8)
blue_upper = np.array([110, 255, 255], np.uint8)
yellow_lower = np.array([22, 60, 200], np.uint8)
yellow_upper = np.array([60, 255, 255], np.uint8)
red = cv2.inRange(hsv, red_lower, red_upper)
blue = cv2.inRange(hsv, blue_lower, blue_upper)
yellow = cv2.inRange(hsv, yellow_lower, yellow_upper)
kernal = np.ones((5, 5), "uint8")
red = cv2.dilate(red, kernal)
res = cv2.bitwise_and(img, img, mask=red)
blue = cv2.dilate(blue, kernal)
res1 = cv2.bitwise_and(img, img, mask=blue)
yellow = cv2.dilate(yellow, kernal)
class SpeedDetector:
def __init__(self):
# initialize the frame dimensions (we'll set them as soon as we read
# the first frame from the video)
self.H = None
self.W = None
self.video_stream = None
self.net = None
self.current_time_stamp = None
self.frame = None
self.rgb = None
self.meter_per_pixel = None
# Load Model
self.load_model()
# Initialize the camera.
self.initialize_camera()
# start the frames per second throughput estimator
self.fps = FPS().start()
self.centroid_object_creator = CentroidObjectCreator()
def load_model(self):
"""
Load our serialized model from disk
"""
logger().info("Loading model name:{}, proto_text:{}.".format(
MODEL_NAME, PROTO_TEXT_FILE))
self.net = cv2.dnn.readNetFromCaffe(PROTO_TEXT_FILE, MODEL_NAME)
# Set the target to the MOVIDIUS NCS stick connected via USB
# Prerequisite: https://docs.openvinotoolkit.org/latest/_docs_install_guides_installing_openvino_raspbian.html
logger().info(
"Setting MOVIDIUS NCS stick connected via USB as the target to run the model."
)
self.net.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD)
def initialize_camera(self):
"""
Initialize the video stream and allow the camera sensor to warmup.
"""
logger().info(
"Warming up Raspberry PI camera connected via the PCB slot.")
self.video_stream = VideoStream(usePiCamera=True).start()
time.sleep(2.0)
# vs = VideoStream(src=0).start()
def grab_next_frame(self):
"""
1. Grab the next frame from the stream.
2. store the current timestamp, and store the new date.
"""
self.frame = self.video_stream.read()
if self.frame is None:
return
self.current_time_stamp = datetime.now()
# resize the frame
self.frame = imutils.resize(self.frame, width=FRAME_WIDTH_IN_PIXELS)
self.rgb = cv2.cvtColor(self.frame, cv2.COLOR_BGR2RGB)
def set_frame_dimensions(self):
"""
If the frame dimensions are empty, set them.
"""
# if the frame dimensions are empty, set them
if not self.W or not self.H:
(self.H, self.W) = self.frame.shape[:2]
self.meter_per_pixel = DISTANCE_OF_CAMERA_FROM_ROAD / self.W
def loop_over_streams(self):
while True:
self.grab_next_frame()
# check if the frame is None, if so, break out of the loop
if self.frame is None:
break
self.set_frame_dimensions()
objects = self.centroid_object_creator.create_centroid_tracker_object(
self.H, self.W, self.rgb, self.net, self.frame)
for speed_tracked_object, objectID, centroid in SpeedTrackerHandler.yield_a_speed_tracker_object(
objects):
SpeedTrackerHandler.compute_speed(self.frame,
speed_tracked_object,
objectID, centroid,
self.current_time_stamp,
self.meter_per_pixel)
SpeedValidator.validate_speed(speed_tracked_object,
self.current_time_stamp,
self.frame)
# if the *display* flag is set, then display the current frame
# to the screen and record if a user presses a key
if OPEN_DISPLAY:
cv2.imshow("Car_car_speed_detector_frame", self.frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key is pressed, break from the loop
if key == ord("q"):
break
# Update the FPS counter
self.fps.update()
def clean_up(self):
# stop the timer and display FPS information
self.fps.stop()
logger().info("elapsed time: {:.2f}".format(self.fps.elapsed()))
logger().info("approx. FPS: {:.2f}".format(self.fps.fps()))
#Close the log file.
SpeedValidator.close_log_file()
# close any open windows
cv2.destroyAllWindows()
# clean up
logger().info("cleaning up...")
self.video_stream.stop()
def perform_speed_detection(self):
while True:
self.loop_over_streams()
self.clean_up()
vs = VideoStream(src=2).start()
# using prerecorded video
else:
vs = cv2.VideoCapture(args["video"])
# allow the camera or video file to warm up
time.sleep(2.0)
firstLoop = True # check if this is the first loop
prevCenter = [0, 0] # value for previous center location
croppedFrame = [0, 0, 0, 0] # y1, y2, x1, x2 for cropping the frame
while True:
frame = vs.read() # read current frame
# if this is from a camera, it's a tuple of [grabbed boolean, frame]
frame = frame[1] if args.get("video", False) else frame
# if this is the end of the video
if frame is None:
break
# resize the frame, blur it, and convert to the HSV
frame = imutils.resize(frame, width=600)
blurred = cv2.GaussianBlur(frame, (11, 11), 0)
hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
# run ROI on first frame and crop frame
if firstLoop:
sl = 'Saturation Low'
vh = 'Value High'
vl = 'Value Low'
wnd = 'Colorbars'
cv2.namedWindow(wnd, flags=cv2.WINDOW_AUTOSIZE)
cv2.createTrackbar(hl, wnd, 0, 179, nothing)
cv2.createTrackbar(hh, wnd, 0, 179, nothing)
cv2.createTrackbar(sl, wnd, 0, 255, nothing)
cv2.createTrackbar(sh, wnd, 0, 255, nothing)
cv2.createTrackbar(vl, wnd, 0, 255, nothing)
cv2.createTrackbar(vh, wnd, 0, 255, nothing)
while True:
frame = cap.read()
frame = cv2.GaussianBlur(frame, (5, 5), 0)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
hul = cv2.getTrackbarPos(hl, wnd)
huh = cv2.getTrackbarPos(hh, wnd)
sal = cv2.getTrackbarPos(sl, wnd)
sah = cv2.getTrackbarPos(sh, wnd)
val = cv2.getTrackbarPos(vl, wnd)
vah = cv2.getTrackbarPos(vh, wnd)
hsvlow = np.array([hul, sal, val])
hsvhigh = np.array([huh, sah, vah])
mask = cv2.inRange(hsv, hsvlow, hsvhigh)
screen = cv2.bitwise_and(frame, frame, mask=mask)
green_upper = (80, 255, 150)
pts = deque(maxlen=args["buffer"])
camera = VideoStream(usePiCamera=args["picamera"] > 0).start()
#go to target
theta_total="1/011/2/020/3/155/4/080"
print theta_total
print 'going to target'
ser.write(theta_total)
#time.sleep(2)
ser.write(theta_total)
#time.sleep(8)
time.sleep(2.0)
while(1):
(frame)=camera.read()
frame=imutils.resize(frame, width=400)
hsv=cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask=cv2.inRange(hsv, green_lower, green_upper)
cv2.imshow('OrigFrame',frame)
#cv2.imshow('Original Mask',mask)
mask=cv2.erode(mask, None, iterations=3)
#cv2.imshow('Erode Mask',mask)
mask=cv2.dilate(mask, None, iterations=3)
cv2.imshow('Dilate Mask',mask)
#contours
cnts=cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
#time.sleep(10)
center=None
if len(cnts)>0:
def run():
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-p",
"--prototxt",
required=False,
help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m",
"--model",
required=True,
help="path to Caffe pre-trained model")
ap.add_argument("-i",
"--input",
type=str,
help="path to optional input video file")
ap.add_argument("-o",
"--output",
type=str,
help="path to optional output video file")
# confidence default 0.4
ap.add_argument("-c",
"--confidence",
type=float,
default=0.4,
help="minimum probability to filter weak detections")
ap.add_argument("-s",
"--skip-frames",
type=int,
default=30,
help="# of skip frames between detections")
args = vars(ap.parse_args())
# initialize the list of class labels MobileNet SSD was trained to
# detect
CLASSES = [
"background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus",
"car", "cat", "chair", "cow", "diningtable", "dog", "horse",
"motorbike", "person", "pottedplant", "sheep", "sofa", "train",
"tvmonitor"
]
# load our serialized model from disk
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# if a video path was not supplied, grab a reference to the ip camera
if not args.get("input", False):
print("[INFO] Starting the live stream..")
#vs = cv2.VideoCapture(cv2.CAP_V4L2)
vs = VideoStream(cv2.CAP_V4L2).start()
time.sleep(2.0)
# otherwise, grab a reference to the video file
else:
print("[INFO] Starting the video..")
vs = cv2.VideoCapture(args["input"])
# initialize the video writer (we'll instantiate later if need be)
writer = None
# initialize the frame dimensions (we'll set them as soon as we read
# the first frame from the video)
W = None
H = None
# instantiate our centroid tracker, then initialize a list to store
# each of our dlib correlation trackers, followed by a dictionary to
# map each unique object ID to a TrackableObject
ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
trackers = []
trackableObjects = {}
# initialize the total number of frames processed thus far, along
# with the total number of objects that have moved either up or down
totalFrames = 0
totalDown = 0
totalUp = 0
x = []
empty = []
empty1 = []
# start the frames per second throughput estimator
fps = FPS().start()
if config.Thread:
vs = thread.ThreadingClass(cv2.CAP_V4L2)
# loop over frames from the video stream
while True:
# grab the next frame and handle if we are reading from either
# VideoCapture or VideoStream
frame = vs.read()
frame = frame[1] if args.get("input", False) else frame
# if we are viewing a video and we did not grab a frame then we
# have reached the end of the video
if args["input"] is not None and frame is None:
break
# resize the frame to have a maximum width of 500 pixels (the
# less data we have, the faster we can process it), then convert
# the frame from BGR to RGB for dlib
frame = imutils.resize(frame, width=400)
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# if the frame dimensions are empty, set them
if W is None or H is None:
(H, W) = frame.shape[:2]
# if we are supposed to be writing a video to disk, initialize
# the writer
if args["output"] is not None and writer is None:
fourcc = cv2.VideoWriter_fourcc(*"MJPG")
writer = cv2.VideoWriter(args["output"], fourcc, 30, (W, H), True)
# initialize the current status along with our list of bounding
# box rectangles returned by either (1) our object detector or
# (2) the correlation trackers
status = "Waiting"
rects = []
# check to see if we should run a more computationally expensive
# object detection method to aid our tracker
if totalFrames % args["skip_frames"] == 0:
# set the status and initialize our new set of object trackers
status = "Detecting"
trackers = []
# convert the frame to a blob and pass the blob through the
# network and obtain the detections
blob = cv2.dnn.blobFromImage(frame, 0.007843, (W, H), 127.5)
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 requiring a minimum
# confidence
if confidence > args["confidence"]:
# extract the index of the class label from the
# detections list
idx = int(detections[0, 0, i, 1])
# if the class label is not a person, ignore it
if CLASSES[idx] != "person":
continue
# compute the (x, y)-coordinates of the bounding box
# for the object
box = detections[0, 0, i, 3:7] * np.array([W, H, W, H])
(startX, startY, endX, endY) = box.astype("int")
# construct a dlib rectangle object from the bounding
# box coordinates and then start the dlib correlation
# tracker
tracker = dlib.correlation_tracker()
rect = dlib.rectangle(startX, startY, endX, endY)
tracker.start_track(rgb, rect)
# add the tracker to our list of trackers so we can
# utilize it during skip frames
trackers.append(tracker)
# otherwise, we should utilize our object *trackers* rather than
# object *detectors* to obtain a higher frame processing throughput
else:
# loop over the trackers
for tracker in trackers:
# set the status of our system to be 'tracking' rather
# than 'waiting' or 'detecting'
status = "Tracking"
# update the tracker and grab the updated position
tracker.update(rgb)
pos = tracker.get_position()
# unpack the position object
startX = int(pos.left())
startY = int(pos.top())
endX = int(pos.right())
endY = int(pos.bottom())
# add the bounding box coordinates to the rectangles list
rects.append((startX, startY, endX, endY))
# draw a horizontal line in the center of the frame -- once an
# object crosses this line we will determine whether they were
# moving 'up' or 'down'
cv2.line(frame, (0, H // 2), (W, H // 2), (153, 204, 102), 3)
cv2.putText(frame, "-Prediction border - Entrance-",
(10, H - ((i * 20) + 200)), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
(0, 0, 0), 1)
# use the centroid tracker to associate the (1) old object
# centroids with (2) the newly computed object centroids
objects = ct.update(rects)
# loop over the tracked objects
for (objectID, centroid) in objects.items():
# check to see if a trackable object exists for the current
# object ID
to = trackableObjects.get(objectID, None)
# if there is no existing trackable object, create one
if to is None:
to = TrackableObject(objectID, centroid)
# otherwise, there is a trackable object so we can utilize it
# to determine direction
else:
# the difference between the y-coordinate of the *current*
# centroid and the mean of *previous* centroids will tell
# us in which direction the object is moving (negative for
# 'up' and positive for 'down')
y = [c[1] for c in to.centroids]
direction = centroid[1] - np.mean(y)
to.centroids.append(centroid)
# check to see if the object has been counted or not
if not to.counted:
# if the direction is negative (indicating the object
# is moving up) AND the centroid is above the center
# line, count the object
if direction < 0 and centroid[1] < H // 2:
totalUp += 1
empty.append(totalUp)
to.counted = True
# if the direction is positive (indicating the object
# is moving down) AND the centroid is below the
# center line, count the object
elif direction > 0 and centroid[1] > H // 2:
totalDown += 1
empty1.append(totalDown)
#print(empty1[-1])
x = []
# compute the sum of total people inside
x.append(len(empty1) - len(empty))
#print("Total people inside:", x)
# if the people limit exceeds over threshold, send an email alert
if sum(x) >= 2:
cv2.putText(frame,
"-ALERT: People limit exceeded-",
(10, frame.shape[0] - 80),
cv2.FONT_HERSHEY_COMPLEX, 0.5,
(0, 0, 255), 2)
to.counted = True
# store the trackable object in our dictionary
trackableObjects[objectID] = to
# draw both the ID of the object and the centroid of the
# object on the output frame
text = "ID {}".format(objectID)
cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (255, 255, 255),
-1)
# construct a tuple of information we will be displaying on the
# info = [
# ("exit", totalUp),
# ("Enter", totalDown),
# ("Status", status),
# ]
info2 = [
("Total People: ", x),
]
# Display the output
# for (i, (k, v)) in enumerate(info):
# text = "{}: {}".format(k, v)
# cv2.putText(frame, text, (10, H - ((i * 20) + 20)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 2)
for (i, (k, v)) in enumerate(info2):
text = "{}: {}".format(k, v)
# cv2.putText(frame, text, (265, H - ((i * 20) + 60)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2) #Red
cv2.putText(frame, text, (15, H - ((i * 20) + 50)),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2) #Red
# Initiate a simple log to save data at end of the day
if config.Log:
datetimee = [datetime.datetime.now()]
d = [datetimee, empty1, empty, x]
export_data = zip_longest(*d, fillvalue='')
with open('Log.csv', 'w', newline='') as myfile:
wr = csv.writer(myfile, quoting=csv.QUOTE_ALL)
wr.writerow(("End Time", "In", "Out", "Total Inside"))
wr.writerows(export_data)
# show the output frame
cv2.imshow("Real-Time Monitoring/Analysis Window", frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"): break
# increment the total number of frames processed thus far and
# then update the FPS counter
totalFrames += 1
fps.update()
if config.Timer:
# Automatic timer to stop the live stream. Set to 8 hours (28800s).
t1 = time.time()
num_seconds = (t1 - t0)
if num_seconds > 28800: break
# stop the timer and display FPS information
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
# # if we are not using a video file, stop the camera video stream
# if not args.get("input", False):
# vs.stop()
#
# # otherwise, release the video file pointer
# else:
# vs.release()
# close any open windows
cv2.destroyAllWindows()
def viewCameraPi(self):
#text = 'This is a message from app to inform that app start running now!'
#statusSMS = outboundSMSviaTwilio(account=self.account, token=self.token, destPhone=self.destPhone1,
# twilioNumber=self.twilioNumber, message_body=text)
#statusSMS = outboundSMSviaTwilio(account=self.account, token=self.token, destPhone=self.destPhone2,
# twilioNumber=self.twilioNumber, message_body=text)
print("START SCRIPT AND MAJOR WARNING!")
statusSMS = 'delivered'
if((statusSMS != 'failed') and (statusSMS != 'undelivered')):
#camera = PiCamera()
#camera.resolution = ( 640, 480)
#camera.framerate = 32
#rawCapture = PiRGBArray(camera, size=( 640, 480))
#self.sumMSE = self.sumSSIM = self.avgMSE = self.avgSSIM = 0
self.tempHour = datetime.datetime.now().hour
self.tempMinute = datetime.datetime.now().minute
self.warmup = 0
vs = VideoStream(usePiCamera=1,resolution=(640,480)).start()
time.sleep(1.2)
fourcc = cv2.VideoWriter_fourcc(*"MJPG")
writer = None
(h, w) = (None, None)
zeros = None
print ("view camera")
while True:
self.warmup+=1
if(self.warmup >=5):
frame = vs.read()
if writer is None:
# store the image dimensions, initialzie the video writer,
# and construct the zeros array
(h, w) = frame.shape[:2]
writer = cv2.VideoWriter('exampleTH3.avi', fourcc, 20,
(w, h), True)
writer.write(frame)
self.curImage = frame
self.getDefImagePerHours()
#write xml
print("process frame thu {}".format(self.warmup-4))
self.writeXML()
#tat chuong trinh sau 5 phut:
if(datetime.datetime.now().minute - self.tempMinute >5):
self.final()
break
# for frame in camera.capture_continuous( rawCapture, format("bgr"), use_video_port = True):
#
# self.curImage = frame.array
# frame = vs.read()
# self.warmup +=1
# if(self.warmup >=5):
# self.getDefImagePerHours()
# # self.getDefImagePerTenMinutes()
#
# #write xml
# print("process frame thu {}".format(self.warmup-4))
# self.writeXML()
#
# #warning
# # self.warning()
#
# #tat chuong trinh sau 5 phut:
# if(datetime.datetime.now().minute - self.tempMinute >5):
# self.final()
# break
# #neu la 16h, script se tu tat
# # tempBreak = datetime.datetime.now().hour
# # if(( tempBreak == 0) or (tempBreak == 6) or (tempBreak == 18) or (tempBreak == 12)):
# # if(datetime.datetime.now().minute == 0):
# # if((datetime.datetime.now().second >= 0) and (datetime.datetime.now().second <=3)):
# # self.final()
# # self.__init__(tempBreak)
#
# # show frame
# # cv2.imshow("image", self.curImage)
# # key = cv2.waitKey(1) & 0xFF
#
# #renew
# rawCapture.truncate(0)
#
# #press 'q' to stop, press any key to continue
# # if(key == ord("q")):
# # break
#call function final
vs.stop()
writer.release()
self.final()
else :
print("send message failed. So App will not run. Sorry for the inconvenience!!")
#OTWARCIE PLIKU DO ZAPISU
file = open('data.txt', 'w')
file.write("n X Y\n")
n = 0
#PETLA GLOWNA
while True:
#PRZECHWYCENIE KLATKI
if from_vfile:
(grabbed, frame) = video_file.read()
#W PRZYPADKU BRAKU KLATEK TO KONIEC VIDEO
if not grabbed:
break
else:
frame = camera.read()
frame = imutils.resize(frame, width=600)
if record_video:
if video_writer is None: #STWORZ INTERFEJS
(h, w) = frame.shape[:2]
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
video_writer = cv2.VideoWriter(args["record_video"], fourcc, 20,
(w, h), True)
if not record_track:
video_writer.write(frame)
#PROGOWANIE
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, greenLower, greenUpper)
fourcc = cv2.VideoWriter_fourcc(*args["codec"])
out = None
(h, w) = (None, None)
zeros = None
A = None
wait_time = None
record = False
WindowName = args["windowname"]
n=0
print("Initialize streaming")
while True:
t0 = time.time()
#grab the frame from the video stream and resize it to have a max width
gray = vs.read()
# frame = imutils.resize(frame, args["width"])
# gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
cv2.imshow(WindowName, gray)
if record == True:
output = np.zeros((h, w),dtype="uint8")
output[0:h, 0:w] = gray
#output = np.zeros((h, w, 3),dtype="uint8")
#output[0:h, 0:w] = frame #grayscale movie
out.write(output)
cv2.imshow(WindowName + "_RECORDING", output)
n+=1
if (n % 100) == 0:
print("The number of frames collected: {0} frames".format(n))
minSize=(MIN_SIZE, MIN_SIZE),
flags=cv2.CASCADE_SCALE_IMAGE
)
if len(faces)>0:
print ("Found {0} faces!".format(len(faces)))
# Draw a rectangle around the faces
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
return frame
while True:
# Capture frame-by-frame
_,frame = video_capture.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
if ENABLE_FACE_DETECT:
resultFrame = faceDetect(gray)
# Display the resulting frame
cv2.imshow('Video', resultFrame)
if ENABLE_FPS:
print("fps:",t.fps())
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything is done, release the capture
# if a video path was not supplied, grab the reference
# to the webcam
if not args.get("video", False):
vs = VideoStream(usePiCamera=1).start()
time.sleep(2.0)
# otherwise, grab a reference to the video file
else:
vs = cv2.VideoCapture(args["video"])
# keep looping
while True:
# grab the current frame
if args.get("video"):
(grabbed, frame) = vs.read()
else:
frame = vs.read()
# if we are viewing a video and we did not grab a frame,
# then we have reached the end of the video
if args.get("video") and not grabbed:
break
# resize the frame, blur it, and convert it to the HSV
# color space
frame = imutils.resize(frame, width=600)
# blurred = cv2.GaussianBlur(frame, (11, 11), 0)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# construct a mask for the color "green", then perform
import cv2
import sys
import time
from imutils.video import VideoStream
import imutils
#setting up the PiCamera and it's variables
video_stream = VideoStream(usePiCamera=True, resolution=(480,320), framerate=25).start()
time.sleep(2)
x = 0
# capture frames from the camera using the piCamera library
while True:
print(x)
# Capture frame-by-frame
image = video_stream.read()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("Frame", gray)
cv2.imwrite("test-images\frame{}.jpg".format(x), gray)
key = cv2.waitKey(1) & 0xFF
x = x + 1
#break code
if key == cv2.waitKey(1) & 0xFF == ord('q'):
break
def main():
# construction des arguments
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--prototxt", required=False, default="/home/pi/Kenobi/recognition/MobileNetSSD_deploy.prototxt.txt",
help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m", "--model", required=False, default="/home/pi/Kenobi/recognition/MobileNetSSD_deploy.caffemodel",
help="path to Caffe pre-trained model")
ap.add_argument("-c", "--confidence", type=float, default=0.6,
help="minimum probability to filter weak detections")
args = vars(ap.parse_args())
# initialiser la liste des objets entrainés par MobileNet SSD
# création du contour de détection avec une couleur attribuée au hasard pour chaque objet
CLASSES = ["arriere-plan", "avion", "velo", "oiseau", "bateau",
"bouteille", "autobus", "voiture", "chat", "chaise", "vache", "table",
"chien", "cheval", "moto", "personne", "plante", "mouton",
"sofa", "train", "moniteur"]
COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))
pygame.mixer.init()
# chargement des fichiers depuis le répertoire de stockage
print(" ...chargement du modèle...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# initialiser la caméra du pi, attendre 2s pour la mise au point ,
# initialiser le compteur FPS
print("...démarrage de la Picamera...")
vs = VideoStream(usePiCamera=True, resolution=(1600, 1200)).start()
time.sleep(2.0)
#fps = FPS().start()
# boucle principale du flux vidéo
while True:
# récupération du flux vidéo, redimension
# afin d'afficher au maximum 800 pixels
frame = vs.read()
frame = imutils.resize(frame, width=800)
# récupération des dimensions et transformation en collection d'images
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 0.007843, (300, 300), 127.5)
# determiner la détection et la prédiction
net.setInput(blob)
detections = net.forward()
# boucle de détection
list_objects = []
for i in np.arange(0, detections.shape[2]):
# calcul de la probabilité de l'objet détecté en fonction de la prédiction
confidence = detections[0, 0, i, 2]
# supprimer les détections faibles inférieures à la probabilité minimale
if confidence > args["confidence"]:
# extraire l'index du type d'objet détecté
# calcul des coordonnées de la fenêtre de détection
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")
# creation du contour autour de l'objet détecté
# insertion de la prédiction de l'objet détecté
#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)
# enregistrement de l'image détectée
#cv2.imwrite("detection.png", frame)
obj = CLASSES[idx]
if obj not in list_objects:
list_objects.append(CLASSES[idx])
# affichage du flux vidéo dans une fenètre
#cv2.imshow("Frame", frame)
#key = cv2.waitKey(1) & 0xFF # ligne necessaire pour l'affichage dans la frame
# Pronounce the objects seen
print(list_objects)
for anobject in list_objects:
path_to_sound = "/home/pi/Kenobi/recognition/vocabulary/" + anobject + ".ogg"
if os.path.isfile(path_to_sound):
pygame.mixer.music.load(path_to_sound)
pygame.mixer.music.play()
# Play until end of music file
while pygame.mixer.music.get_busy() == True:
pygame.time.Clock().tick(10)
# la touche q permet d'interrompre la boucle principale
#if key == ord("q"):
# break
# mise à jour du FPS
#fps.update()
# arret du compteur et affichage des informations dans la console
#fps.stop()
#print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
#print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
cv2.destroyAllWindows()
vs.stop()
class yawn_detection:
def __init__(self, shape_predictor=None, alarm=None, webcam=None):
#shape_predictor = self.shape_predictor
#alarm = self.alarm
#webcam = self.webcam
self.shape_predictor = 'shape_predictor_68_face_landmarks.dat'
self.alarm = 'alarm.wav'
self.webcam = 'http://10.24.201.216:4747/mjpegfeed?640x480'
# define two constants, one for the eye aspect ratio to indicate
# blink and then a second constant for the number of consecutive
# frames the eye must be below the threshold for to set off the
# alarm
self.MOUTH_AR_THRESH = 0.65
self.MOUTH_AR_CONSEC_FRAMES = 15
# initialize the frame counter as well as a boolean used to
# indicate if the alarm is going off
self.COUNTER = 0
self.ALARM_ON = False
self.detector = dlib.get_frontal_face_detector()
self.predictor = dlib.shape_predictor(self.shape_predictor)
self.STATUS = False
# grab the indexes of the facial landmarks for the mouth
(self.Start, self.End) = face_utils.FACIAL_LANDMARKS_IDXS["mouth"]
def mouth_aspect_ratio(self, mouth):
#vertical dist (x-y)
A = dist.euclidean(mouth[1], mouth[5])
B = dist.euclidean(mouth[2], mouth[4])
C = dist.euclidean(mouth[0], mouth[3])
self.ratio = (A + B) / (2.0 * C)
return self.ratio
def sound_alarm(self, path):
# play an alarm sound
playsound.playsound(path)
def vs_loop(self):
# start the video stream thread
print("[INFO] starting video stream thread...")
self.vs = VideoStream(
src='http://10.24.201.216:4747/mjpegfeed?640x480').start()
#print(self.vs.isOpened())
time.sleep(1.0)
while True:
# grab the frame from the threaded video file stream, resize
# it, and convert it to grayscale
# channels)
frame = self.vs.read()
frame = imutils.resize(frame, width=450)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# detect faces in the grayscale frame
self.rects = self.detector(gray, 0)
# loop over the face detections
for rect in self.rects:
# determine the facial landmarks for the face region, then
# convert the facial landmark (x, y)-coordinates to a NumPy
# array
shape = self.predictor(gray, rect)
shape = face_utils.shape_to_np(shape)
mouth = shape[self.Start:self.End]
MAR = self.mouth_aspect_ratio(mouth)
mouthHull = cv2.convexHull(mouth)
cv2.drawContours(frame, [mouthHull], -1, (0, 255, 0),
1) #what do these numbers mean??
if MAR < self.MOUTH_AR_THRESH:
self.COUNTER += 1
# if the eyes were closed for a sufficient number of
# then sound the alarm
if self.COUNTER >= self.MOUTH_AR_CONSEC_FRAMES:
self.STATUS = True
# draw an alarm on the frame
cv2.putText(frame, "DROWSINESS ALERT!", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255),
2)
else:
self.STATUS = False
else:
self.COUNTER = 0
ALARM_ON = False
cv2.putText(frame, "MAR: {:.2f}".format(MAR), (300, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
import sys
sys.path.append('/usr/local/lib')
import socket
import time
from imutils.video import VideoStream
from imagezmq import ImageSender
sender = ImageSender(connect_to='tcp://127.0.0.1:5555')
cam_name = socket.gethostname()
cam = VideoStream(src=0).start()
time.sleep(2.0)
while True: # send images as stream until Ctrl-C
image = cam.read()
sender.send_image(cam_name, image)
"""test_2_rpi_send_images.py -- send PiCamera image stream.
A Raspberry Pi test program that uses imagezmq to send image frames from the
PiCamera continuously to a receiving program on a Mac that will display the
images as a video stream.
This program requires that the image receiving program be running first. Brief
test instructions are in that program: test_2_mac_receive_images.py.
"""
import sys
import socket
import time
import cv2
from imutils.video import VideoStream
import imagezmq
# use either of the formats below to specifiy address of display computer
# sender = imagezmq.ImageSender(connect_to='tcp://jeff-macbook:5555')
sender = imagezmq.ImageSender(connect_to='tcp://192.168.1.190:5555')
rpi_name = socket.gethostname() # send RPi hostname with each image
picam = VideoStream(usePiCamera=True).start()
time.sleep(2.0) # allow camera sensor to warm up
while True: # send images as stream until Ctrl-C
image = picam.read()
sender.send_image(rpi_name, image)
# otherwise, grab a reference to the video file else: video_file = cv2.VideoCapture(args["video"]) # keep looping while True: # grab the current frame if from_vfile: (grabbed, frame) = video_file.read() # if we are viewing a video and we did not grab a frame, # then we have reached the end of the video if not grabbed: break else: frame = camera.read() # resize the frame, blur it, and convert it to the HSV # color space frame = imutils.resize(frame, width=600) # record video if record_video: if video_writer is None: # create interface (h, w) = frame.shape[:2] fourcc = cv2.VideoWriter_fourcc(*'MJPG') # Note: the extension of the filename must be avi video_writer = cv2.VideoWriter(args["record_video"], fourcc, 20, (w,h), True) #zeros = np.zeros((h,w), dtype="uint8")
class Vision(object):
def __init__(self, use_pi_cam=False):
self.camera = VideoStream(usePiCamera=use_pi_cam)
self.bounds_file = open("./scripts/colors.txt", "r")
self.color_info = ast.literal_eval(self.bounds_file.readline())
self.colors = len(self.color_info)
self.camera.start()
time.sleep(2)
def find_color_in_frame(self,
signature,
frame,
show_feed,
threshold=50,
show_max=True):
start = time.time()
result = []
blurred = cv2.GaussianBlur(frame, (11, 11), 0)
lower = np.array([40, 70, 70])
upper = np.array([80, 200, 200])
# lower = np.fromstring(self.color_info[signature]['bounds'][0][1:-1], dtype=int, sep=' ')
# upper = np.fromstring(self.color_info[signature]['bounds'][1][1:-1], dtype=int, sep=' ')
blurred = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(blurred, lower, upper)
mask = cv2.erode(mask, None, iterations=2)
mask = cv2.dilate(mask, None, iterations=2)
contours = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
if show_feed:
cv2.imshow(self.color_info[signature]['color'], mask)
if len(contours) > 0:
if show_max:
contours = [max(contours, key=cv2.contourArea)]
for c in contours:
rect = cv2.minAreaRect(c)
box = cv2.boxPoints(rect)
box = np.int0(box)
if cv2.contourArea(box) > threshold:
cv2.drawContours(frame, [box], 0, (0, 0, 255), 3)
font = cv2.QT_FONT_NORMAL
cv2.putText(frame, self.color_info[signature]['color'],
(box[0][0], box[0][1]), font, 0.5,
(255, 255, 255), 1, cv2.LINE_AA)
M = cv2.moments(box)
cx = int(M['m10'] / M['m00'])
cy = int(M['m01'] / M['m00'])
result.append({
'area': cv2.contourArea(box),
'x': cx,
'y': cy,
'color': self.color_info[signature]['color'],
'time': time.time() - start
})
return frame, result
def get_color(self, signature, show_feed=False):
frame = self.camera.read()
frame = imutils.resize(frame, width=400)
frame, result = self.find_color_in_frame(signature, frame, show_feed)
if show_feed:
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) #
if key == 27:
self.camera.stop()
exit()
return result
def get_colors(self, threshold, show_feed=False):
frame = self.camera.read()
frame = imutils.resize(frame, width=400)
result = []
for x in range(0, self.colors):
if self.color_info[x]:
frame, cont = self.find_color_in_frame(x,
threshold=threshold,
frame=frame)
result.append(cont)
if show_feed:
cv2.imshow("Frame", frame)
key = cv2.waitKey(1)
if key == 27:
# self.camera.stop()
exit()
return result
print("[INFO] warming up camera...")
vs = VideoStream(usePiCamera=args["picamera"] > 0).start()
time.sleep(2.0)
# initialize the FourCC, video writer, dimensions of the frame, and
# zeros array
fourcc = cv2.cv.FOURCC(*args["codec"])
writer = None
(h, w) = (None, None)
zeros = None
# loop over frames from the video stream
while True:
# grab the frame from the video stream and resize it to have a
# maximum width of 300 pixels
frame = vs.read()
frame = imutils.resize(frame, width=300)
# check if the writer is None
if writer is None:
# store the image dimensions, initialzie the video writer,
# and construct the zeros array
(h, w) = frame.shape[:2]
writer = cv2.VideoWriter(args["output"], fourcc, args["fps"],(w, h), True)
zeros = np.zeros((h, w), dtype="uint8")
# break the image into its RGB components, then construct the
# RGB representation of each frame individually
(B, G, R) = cv2.split(frame)
#R = cv2.merge([zeros, zeros, R])
#G = cv2.merge([zeros, G, zeros])
import cv2
helmet_cascade = cv2.CascadeClassifier('LBPCascade_helmet.xml')
#motorcycle_cascade = cv2.CascadeClassifier('LBPcascade_motorcycle.xml')
print("[INFO] starting cameras...")
picam = VideoStream(usePiCamera=True).start()
webcam = VideoStream(src=0).start()
time.sleep(2.0)
print(helmet_cascade)
time.sleep(5)
while True:
frames = []
#for stream in picam:
frame = webcam.read()
frame = imutils.resize(frame, width=400)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#locs = motion.update(gray)
helmet = helmet_cascade.detectMultiScale(gray, 1.3, 5)
#if total<32:
#frames.append(gray)
#continue
frames.append(gray)
timestamp = datetime.datetime.now()
ts = timestamp.strftime("%A %d %B %Y %I:%M:%Sp")
for (frame, name) in zip(frames, ("Picamera")):
