def Cov():
global time
try:
from pyimagesearch.centroidtracker import CentroidTracker
from pyimagesearch.trackableobject import TrackableObject
from imutils.video import VideoStream
from imutils.video import FPS
import numpy as np
import argparse
import imutils
import time
import dlib
import cv2
from datetime import datetime
import pyodbc
conn = pyodbc.connect(
'DRIVER={SQL Server};SERVER=182.156.200.178;DATABASE=python;UID=sa;PWD=elmcindia786@'
)
entry = conn.cursor()
exitt = conn.cursor()
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
"""CAMERA IS DEFINED HERE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""
cam = "rtsp://*****:*****@[email protected]/cam/realmonitor?channel=1&subtype=0"
ap.add_argument("-p",
"--prototxt",
default="mobilenet_ssd/MobileNetSSD_deploy.prototxt",
help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m",
"--model",
default="mobilenet_ssd/MobileNetSSD_deploy.caffemodel",
help="path to Caffe pre-trained model")
ap.add_argument("-i",
"--input",
type=str,
default=cam,
help="path to optional input video file")
ap.add_argument("-o",
"--output",
type=str,
default="output/2.mp4",
help="path to optional output video file")
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
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# if a video path was not supplied, grab a reference to the webcam
if not args.get("input", False):
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
# otherwise, grab a reference to the video file
else:
print("[INFO] opening video file...")
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
Up = []
Down = []
# 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()
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=500)
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), (0, 255, 255), 2)
# 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
Up.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
Down.append(totalDown)
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, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0),
-1)
# construct a tuple of information we will be displaying on the
# frame
info = [
("Up", totalUp),
("Down", totalDown),
("Status", status),
]
today = datetime.today()
if len(Up) > 0:
print("up:", str(Up))
print("Log", (str(today)))
sql = "INSERT INTO [python].[dbo].[peopleCounter] (status, logDateTime, personcount) VALUES ('0','" + str(
today) + "','1')"
entry.execute(sql)
conn.commit()
Up.clear()
if len(Down) > 0:
print("Down:", str(Down))
print("Log", (str(today)))
sql = "INSERT INTO [python].[dbo].[peopleCounter] (status, logDateTime, personcount) VALUES ('1','" + str(
today) + "','1')"
exitt.execute(sql)
conn.commit()
Down.clear()
# loop over the info tuples and draw them on our frame
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, 255), 2)
# check to see if we should write the frame to disk
# if writer is not None:
# writer.write(frame)
# 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
# increment the total number of frames processed thus far and
# then update the FPS counter
totalFrames += 1
fps.update()
# 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()))
# check to see if we need to release the video writer pointer
if writer is not None:
writer.release()
time.sleep(1)
Recall()
# 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()
except Exception as e:
print(e)
time.sleep(1)
print("sd")
Recall()
print("[INFO] warming up camera...")
camera_right = CSICamera(capture_device=0, width=1280, height=720)
camera_left = CSICamera(capture_device=1, width=1280, height=720)
time.sleep(2.0)
# initialize the frame dimensions (we'll set them as soon as we read
# the first frame from the video)
H = None
W = None
cnt = 0
# 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=conf["max_disappear"],
maxDistance=conf["max_distance"])
trackers = []
trackableObjects = {}
# keep the count of total number of frames
totalFrames = 0
# initialize the log file
logFile = None
# initialize the list of various points used to calculate the avg of
# the vehicle speed
# points = [("A", "B"), ("B", "C"), ("C", "D")]
# start the frames per second throughput estimator
fps = FPS().start()
else:
print("[INFO] opening video file...")
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
# 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
def gen():
# construct the argument parse and parse the arguments
now = datetime.datetime.now()
#if now.hour == 18 and now.minute==0 :
#fireInterVal(now.hour)
#if now.hour == 9 and now.minute==0 :
#fireInterVal(now.hour)
#if now.hour == 12 and now.minute==0 :
#fireInterVal(now.hour)
#if now.hour == 15 and now.minute==0 :
#fireInterVal(now.hour)
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--prototxt", default='mobilenet_ssd/MobileNetSSD_deploy.prototxt',
help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m", "--model", default='mobilenet_ssd/MobileNetSSD_deploy.caffemodel',
help="path to Caffe pre-trained model")
ap.add_argument("-i", "--input", type=str,default='videos/example_07.mp4',
help="path to optional input video file")
ap.add_argument("-o", "--output", type=str,default='output/webcam_output.avi',
help="path to optional output video file")
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
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# if a video path was not supplied, grab a reference to the webcam
if not args.get("input", False):
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
# otherwise, grab a reference to the video file
else:
print("[INFO] opening video file...")
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
# 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()
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=500)
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]
# 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), (0, 255, 255), 2)
# 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
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
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, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
# construct a tuple of information we will be displaying on the
# frame
info = [
("Up", totalUp),
("Down", totalDown),
("Status", status),
]
if status=='Tracking':
currentCount = totalDown-totalUp
if currentCount!=previousCount:
fireUpdate(currentCount)
# loop over the info tuples and draw them on our frame
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, 255), 2)
ret, jpeg = cv2.imencode('.jpg', frame)
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + jpeg.tobytes() + b'\r\n\r\n')
totalFrames += 1
fps.update()
fps.stop()
vs.release()
def multiple_detection(vs, num):
#vs= VideoStream(src=0).start()
time.sleep(2.0)
# otherwise, grab a reference to the video file
# 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
# 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()
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=500)
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"
cam_list[num] = 0
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 = "Detected"
cam_list[num] = 1
# 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), (W, H), (0, 255, 255), 2)
# 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
# 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
# # 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, (0, 255, 0), 2)
# cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
# construct a tuple of information we will be displaying on the
# frame
# info = [
# ("Countrer", totalUp),
# ("Status", status),
# ]
# loop over the info tuples and draw them on our frame
# for (i, k) in enumerate(info):
# # text = "{}: {}".format(k, v)
# # cv2.putText(frame, text, (10, H - ((i * 20) + 20)),
# # cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
print("Status:", status)
# print("counter",i)
# check to see if we should write the frame to disk
if writer is not None:
writer.write(frame)
# 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
# increment the total number of frames processed thus far and
# then update the FPS counter
totalFrames += 1
fps.update()
# 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()))
# check to see if we need to release the video writer pointer
if writer is not None:
writer.release()
# 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 make_prediction(in_filename, out_filename, confidence_threshold=0.3, skip_frames=200, caffe_prototxt_file=None, model_file=None):
# initialize the list of class labels MobileNet SSD was trained to
# detect
CLASSES = ["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
print("[INFO] loading model...")
# net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
net = model_zoo.get_model('ssd_512_resnet50_v1_voc', pretrained=True)
# if a video path was not supplied, grab a reference to the webcam
if not in_filename:
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
# otherwise, grab a reference to the video file
else:
print("[INFO] opening video file...")
vs = cv2.VideoCapture(in_filename)
# 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=10, 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
totalIn = 0
totalOut = 0
# 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()
frame = frame[1] if in_filename 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 in_filename 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
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 out_filename is not None and writer is None:
fourcc = cv2.VideoWriter_fourcc(*"MJPG")
writer = cv2.VideoWriter(out_filename, 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 % 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
class_IDs, scores, bounding_boxes = net(data.transforms.presets.ssd.transform_test(mx.nd.array(frame), 270)[0])
# loop over the detections
for i, (class_ID, score, bounding_box) in enumerate(zip(class_IDs[0], scores[0], bounding_boxes[0])):
class_ID = int(class_ID[0].asnumpy()[0])
# extract the confidence (i.e., probability) associated
# with the prediction
confidence = score[0].asnumpy()[0]
# filter out weak detections by requiring a minimum
# confidence
if confidence > confidence_threshold:
# extract the index of the class label from the
# detections list
idx = int(class_ID)
# 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 = bounding_box.asnumpy()
(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))
# 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]
x = [c[0] for c in to.centroids]
direction_y = centroid[1] - np.mean(y)
direction_x = centroid[0] - np.mean(x)
to.centroids.append(centroid)
cur_x = np.mean(x)
cur_y = np.mean(y)
x_low, x_high, y_low, y_high = W // 3, 2 * W // 3, H // 4, 3 * H // 4
cv2.line(frame, (x_low, y_low), (x_low, y_high), color=(0, 255, 0))
cv2.line(frame, (x_high, y_low), (x_high, y_high), color=(0, 255, 0))
cv2.line(frame, (x_high, y_low), (x_low, y_low), color=(0, 255, 0))
cv2.line(frame, (x_high, y_high), (x_low, y_high), color=(0, 255, 0))
# 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
delta_pixels = 10
pred_x, pred_y = cur_x + delta_pixels * np.sign(direction_x), cur_y + delta_pixels * np.sign(direction_y)
if ((cur_x < x_low or cur_x > x_high) and pred_x >= x_low and pred_x >= x_high) and ((cur_y < y_low or cur_y > y_high) and pred_y >= y_low and pred_y >= y_high):
totalIn += 1
to.counted = True
elif cur_x >= x_low and cur_x <= x_high and cur_y >= y_low or cur_y <= y_high:
totalOut += 1
to.counted = True
elif cur_x >= x_low and cur_x <= x_high and cur_y >= y_low and cur_y <= y_high and (pred_x < x_low or pred_x > x_high or pred_y < y_low or pred_y > y_high):
totalOut += 1
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, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
# construct a tuple of information we will be displaying on the
# frame
info = [
("In", totalIn),
("Out", totalOut),
("Status", status),
]
# loop over the info tuples and draw them on our frame
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, 255), 2)
# check to see if we should write the frame to disk
if writer is not None:
writer.write(frame)
# 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
# increment the total number of frames processed thus far and
# then update the FPS counter
totalFrames += 1
fps.update()
# 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()))
# check to see if we need to release the video writer pointer
if writer is not None:
writer.release()
# if we are not using a video file, stop the camera video stream
if not in_filename:
vs.stop()
# otherwise, release the video file pointer
else:
vs.release()
# close any open windows
cv2.destroyAllWindows()
# 2: Load the trained weights into the model.
# TODO: Set the path of the trained weights.
weights_path = 'VGG_VOC0712Plus_SSD_512x512_ft_iter_160000.h5'
model.load_weights(weights_path, by_name=True)
# 3: Compile the model so that Keras won't complain the next time you load it.
adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0)
model.compile(optimizer=adam, loss=ssd_loss.compute_loss)
confidence_thresh = 0.55
ct = CentroidTracker()
writer = None
orig_images = [] # Store the images here.
input_images = [] # Store resized versions of the images here.
VideoInput = [
'gambir011', 'gambir014', 'lenteng', 'pulogadung', 'kebonsirih',
'kananbagus'
]
objects_1 = []
IDCentroid = []
btsMerah = []
btsHijau = []
hijau = 'hijau'
merah = 'merah'
def main(dataPoints_normal, dataPoints_perspective):
# start without log the data
loggingPrespective = False
loggingNormal = False
mouse_capturing = MouseCapture([])
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-v",
"--video_source",
required=False,
default='/dev/video0',
help="The video to use as a source")
ap.add_argument("-f",
"--framesToEscape",
required=False,
default=30,
help="Capture data every 30 frames")
ap.add_argument("-p",
"--prototxt",
required=False,
help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-c",
"--confidence",
type=float,
default=0.5,
help="minimum probability to filter weak detections")
ap.add_argument("-m",
"--model",
required=False,
help="path to Caffe pre-trained model")
args = vars(ap.parse_args())
# initialize our centroid tracker and frame dimensions
ct = CentroidTracker()
(H, W) = (None, None)
# create file to write the data to
# if os.path.exists("datasetPoints.csv"):
# dataPoints = open("datasetPoints.csv", "w")
# else:
# dataPoints = open("datasetPoints.csv", "w+")
# load our serialized model from disk
print("[INFO] loading model...")
out_size = 1000
# Defult value for the first point for prespctive transormed
pts1 = np.float32([[155, 120], [480, 120], [20, 475], [620, 475]])
pts1 = np.float32([[0, 0], [out_size, 0], [0, out_size],
[out_size, out_size]])
# initialize the video stream and allow the camera sensor to warmup
print(f"[INFO] starting video stream from source: {args['video_source']}")
vs = cv2.VideoCapture(args['video_source'])
print(vs.read())
framecount = 0
# Find OpenCV version
(major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.')
# With webcam get(CV_CAP_PROP_FPS) does not work.
# Let's see for ourselves.
if int(major_ver) < 3:
fps = vs.get(cv2.cv.CV_CAP_PROP_FPS)
# FrameRate = cv2.VideoCapture(args['framesToEscape'])
print("Frames per second using video.get(cv2.cv.CV_CAP_PROP_FPS): {0}".
format(fps))
else:
fps = vs.get(cv2.CAP_PROP_FPS)
# FrameRate = cv2.VideoCapture(args['framesToEscape'])
print(
"Frames per second using video.get(cv2.CAP_PROP_FPS) : {0}".format(
fps))
# create the frame windows
cv2.namedWindow("Frame")
# attach the mouse call bace event to the windows
cv2.setMouseCallback("Frame", mouse_capturing)
# store the 4 points that will be prespctive transormed in the list
#time.sleep(2.0)
# from test import TestKeypointRcnn, torch_tensor_to_img
from Person_det_track import Pipeline
# net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# net = TestKeypointRcnn(920, out_size)
net = Pipeline()
# loop over the frames from the video stream
while True:
# read the next frame from the video stream and resize it
# time.sleep(2.0)
r, frame = vs.read()
framecount += 1
result = frame
# frame = imutils.resize(frame, width=800)
for center_position in mouse_capturing.pointList:
# print(center_position)
cv2.circle(frame, center_position, 5, (0, 0, 255), -1)
# # construct a blob from the frame, pass it through the network,
# # obtain our output predictions, and initialize the list of
# # bounding box rectangles
# blob = cv2.dnn.blobFromImage(frame, 1.0, (W, H),
# (104.0, 177.0, 123.0))
rects = []
#################################################################
# When using the rcnn model in test.py
# predictions, frame = net(frame)
# frame = torch_tensor_to_img(frame)
# result = frame.copy()
# predictions_length = predictions['boxes'].shape[0]
#################################################################
#################################################################
# When using the Person_det_track.py from the
# Person-Detection-and-Tracking
new_frame, predictions = net(frame)
predictions_length = len(predictions)
#################################################################
# if the frame dimensions are None, grab them
if W is None or H is None:
(H, W) = frame.shape[:2]
H = int(H / out_size)
W = int(W / out_size)
################################################################
# here where the prespective transformation should happen
# the following link is showing that we can apply to a point
#
################################################################
if len(mouse_capturing.pointList) >= 4:
pts1 = np.float32([[mouse_capturing.pointList[0]],
[mouse_capturing.pointList[1]],
[mouse_capturing.pointList[2]],
[mouse_capturing.pointList[3]]])
# print("point0:", [pointList[0]], "point1:", [pointList[1]], "point2:", [pointList[2]], "point3:",[pointList[3]])
pts2 = np.float32([[0, 0], [result.shape[1], 0], [0, result.shape[0]],
[result.shape[1], result.shape[0]]])
# calculate the the prepective transformation materix.
matrix = cv2.getPerspectiveTransform(pts1, pts2)
# apply the transformation to the result frame
result = cv2.warpPerspective(frame, matrix, result.shape[:2])
# loop over the detections
for i in range(0, predictions_length):
# filter out weak detections by ensuring the predicted
# probability is greater than a minimum threshold
# # If using the pytorch version in test.py
# score = predictions['scores'][i]
# # If using the Person-Detection-and-Tracking
score = 1
if score > args["confidence"]:
# compute the (x, y)-coordinates of the bounding box for
# the object, then update the bounding box rectangles list
# # If using the pytorch version in test.py
# box = predictions['boxes'][i].cpu().detach().numpy()
# # If using the Person-Detection-and-Tracking
box = np.array(predictions[i].box)
rects.append(box.astype("int"))
# draw a bounding box surrounding the object so we can
# visualize it
(startX, startY, endX,
endY) = (box * np.array([W, H, W, H])).astype("int")
cv2.rectangle(frame, (startX, startY), (endX, endY),
(0, 255, 0), 2)
# update our centroid tracker using the computed set of bounding
# box rectangles
objects = ct.update(rects)
# loop over the tracked objects
for (objectID, centroid) in objects.items():
# 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, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
# captured data after 30 frame
if framecount >= fps:
# print('Frame number', framecount)
framecount = 0
if loggingNormal:
# print("wrote normal")
dataPoints_normal.writerow({
'Datetime': datetime.now(),
'ObjectID': objectID,
'xLocation': centroid[0],
'yLocation': centroid[1]
})
# '{0},{1},{2},{3}\n'.format(datetime.now(), objectID, centroid[0], centroid[1]))
# Print the object time, object ID , x, y
# These points are from the orginal frame
transformed_points = cv2.perspectiveTransform(
centroid.reshape(1, 1, -1).astype(np.float), matrix)[0, 0]
# if logging is activited
if (loggingPrespective):
# log the interested area
if transformed_points[0] > 0 and transformed_points[1] > 0 and \
transformed_points[0] < result.shape[0] and transformed_points[1] < result.shape[1]:
# print(datetime.now(), ";", objectID, ";",transformed_points[0], ";", transformed_points[1])
# print("wrote Perspective")
# write to the file
dataPoints_perspective.writerow({
'Datetime':
datetime.now(),
'ObjectID':
objectID,
'xLocation':
transformed_points[0],
'yLocation':
transformed_points[1]
})
# .write('{0},{1},{2},{3}\n'.format(datetime.now(),objectID,transformed_points[0],transformed_points[1]))
# cv2.circle(result, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
cv2.circle(result, (int(transformed_points[0]),
int(transformed_points[1])), 3,
(255, 100, 0), 2)
# show the output frame
cv2.imshow("Frame", frame)
cv2.imshow("Result", result)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
if key == ord("d"):
mouse_capturing.pointList = []
if key == ord("r"):
print("[INFO] Starting to log perspective")
loggingPrespective = True
if key == ord("n"):
print("[INFO] Starting to log normal")
loggingNormal = True
if key == ord("s"):
logging = False
# do a bit of cleanup
cv2.destroyAllWindows()
def main(args, total=0):
WIDTH = 300
HEIGHT = 300
try:
# direction going in
in_direction = MoveDirection(args["direction"].lower())
except:
raise ValueError(
"Only 'up' or 'down', 'left', 'right' directions are supported")
centroid_idx = get_horiz_vert(in_direction).value
is_visual = args["visual"]
# mask used to indicate the "in" direction
if is_visual:
mask = np.zeros((HEIGHT, WIDTH, 3)).astype('uint8')
w = WIDTH // 2
h = HEIGHT // 2
if in_direction == MoveDirection.LEFT:
mask[:, :w, 2] = 255
elif in_direction == MoveDirection.RIGHT:
mask[:, w:, 2] = 255
elif in_direction == MoveDirection.DOWN:
mask[h:, :, 2] = 255
else:
mask[:h, :, 2] = 255
# store or ignore the count we receive in the reset request
store_count = args['set_count']
if args["debug"]:
logging.info("Please attach a debugger to port 5680")
import ptvsd
ptvsd.enable_attach(('0.0.0.0', 5680))
ptvsd.wait_for_attach()
ptvsd.break_into_debugger()
if args["id"] is None:
raise ValueError("id must be specified")
global running, sess
# load our serialized model from disk
logging.info("loading model...")
detector_type = args["detector"]
if detector_type == "opencv":
detector = DetectorCV(args["model"],
args["prototxt"],
confidence_thresh=args["confidence"])
elif detector_type == "onnx":
detector = DetectorOnnx(args["model"])
else:
raise ValueError(
f"Unkonwn detector: {args['detector']}. Use 'opencv' or 'onnx'")
is_rtsp = args["input"] is not None and args["input"].startswith("rtsp://")
source = "prod" if is_rtsp else "test"
# if a video path was not supplied, grab a reference to the webcam
logging.info("starting video stream...")
if not args.get("input", False):
vs = VideoStream(src=0).start()
time.sleep(2.0)
# otherwise, grab a reference to the video file
else:
if (not is_rtsp and not os.path.exists(args["input"])):
raise FileNotFoundError(args["input"])
vs = cv2.VideoCapture(args["input"])
if is_rtsp:
vs.set(cv2.CAP_PROP_BUFFERSIZE, 600)
# 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
centroidTracker = 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 = total if store_count and (
in_direction == MoveDirection.DOWN
or in_direction == MoveDirection.RIGHT) else 0
totalUp = total if store_count and (
in_direction == MoveDirection.UP
or in_direction == MoveDirection.LEFT) else 0
# detailed counters of foot traffic
currentIn = 0
currentOut = 0
# report counts from this camera
messageEvery = args["report_count"]
# 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()
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 messenger.should_reset() or (args["input"] is not None
and frame is None):
logging.debug("We are DONE!")
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 = cv2.resize(frame, (WIDTH, HEIGHT),
interpolation=cv2.INTER_LINEAR)
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]
# count the object when it's crossing either mid-height or mid-width
crossingDimension = get_dir_dimension(in_direction, W, H) // 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 = []
detections = detector.detect(frame)
for startX, startY, endX, endY in detections:
# construct a dlib rectangle object from the bounding
# box coordinates and then start the dlib correlation
# tracker
cv2.rectangle(frame, (startX, startY), (endX, endY),
(255, 0, 0), 2)
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"
cv2.rectangle(frame, (startX, startY), (endX, endY),
(255, 0, 0), 2)
# 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'
if is_visual:
if get_horiz_vert(in_direction) == CountDirection.VERTICAL:
cv2.line(frame, (0, H // 2), (W, H // 2), (0, 255, 255), 2)
else:
cv2.line(frame, (W // 2, 0), (W // 2, H), (0, 255, 255), 2)
# use the centroid tracker to associate the (1) old object
# centroids with (2) the newly computed object centroids
objects = centroidTracker.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
trackableObject = trackableObjects.get(objectID, None)
if trackableObject is None:
trackableObject = TrackableObject(objectID, centroid)
# otherwise, there is a trackable object so we can utilize it
# to determine direction
else:
# where have we seen it last?
xy = trackableObject.centroids[-1][centroid_idx]
# see if we need to count it.
# we count iff the centroid crossed the mid-line since its last known position
direction = get_trigger_count(xy, centroid[centroid_idx],
crossingDimension)
trackableObject.centroids.append(centroid)
# if the direction is negative (indicating the object
# is moving up/left) AND the centroid is above the center
# line, count the object
if direction < 0:
totalUp += 1
currentOut += 1
# if the direction is positive (indicating the object
# is moving down/right) AND the centroid is below the
# center line, count the object
elif direction > 0:
totalDown += 1
currentIn += 1
# store the trackable object in our dictionary
trackableObjects[objectID] = trackableObject
# draw both the ID of the object and the centroid of the
# object on the output frame
if is_visual:
text = "ID {}".format(objectID)
cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0),
-1)
# up or down counting - based on what we have parameterized
total = totalDown - totalUp
if in_direction == MoveDirection.UP or in_direction == MoveDirection.LEFT:
total = -total
# swap current "in" and "out" counters depending on direction
tmp = currentIn
currentIn = currentOut
currentOut = tmp
messenger.update_count(total)
if totalFrames % messageEvery == 0:
# messenger has been initialized with resettableCount
messenger.send_count()
# send current "in" and "out" foot traffic and update direction
messenger.send_traffic_details(currentIn, currentOut, source)
currentIn = currentOut = 0
if is_visual:
# construct a tuple of information we will be displaying on the
# frame
up, down = get_cur_direction_names(in_direction)
info = [
(up, totalUp),
(down, totalDown),
("Total", total),
("Status", status),
]
# loop over the info tuples and draw them on our frame
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, 255), 2)
# check to see if we should write the frame to disk
if writer is not None:
writer.write(frame)
if is_visual:
img = cv2.addWeighted(frame, 0.8, mask, 0.2, 0)
# show the output frame
cv2.imshow("Frame", img)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
# and completely stop running
if key == ord("q"):
running = False
break
# increment the total number of frames processed thus far and
# then update the FPS counter
totalFrames += 1
fps.update()
# stop the timer and display FPS information
fps.stop()
logging.info("elapsed time: {:.2f}".format(fps.elapsed()))
logging.info("approx. FPS: {:.2f}".format(fps.fps()))
# check to see if we need to release the video writer pointer
if writer is not None:
writer.release()
# 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()
def run(self):
self.signals.changeTitleBox.emit(" Sol Toplam\n"
"Sağ Toplam\n"
" Durum")
self.vs = cv2.VideoCapture(self.video_source)
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(self.model_path, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
label_map = label_map_util.load_labelmap(self.label_path)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=self.num_classes, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
W = None
H = None
ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
trackers = []
trackableObjects = {}
totalFrames = 0
skip_frame = 10
fps = FPS().start()
# Operation
with detection_graph.as_default():
with tf.Session(graph=detection_graph) as sess:
while True:
ret, self.frame = self.vs.read()
if self.frame is None or self.stopped:
print("Video stream ended.")
break
self.frame = imutils.resize(
self.frame,
width=1000) # Less data we have, faster we are.
rgb = cv2.cvtColor(self.frame, cv2.COLOR_BGR2RGB)
self.frame = rgb
if W is None or H is None:
(H, W, ch) = self.frame.shape
self.status = "Bekliyor"
rects = []
if totalFrames % skip_frame == 0:
self.status = "Saptanıyor"
trackers = []
frame_expanded = np.expand_dims(self.frame, axis=0)
image_tensor = detection_graph.get_tensor_by_name(
'image_tensor:0')
boxes = detection_graph.get_tensor_by_name(
'detection_boxes:0')
scores = detection_graph.get_tensor_by_name(
'detection_scores:0')
classes = detection_graph.get_tensor_by_name(
'detection_classes:0')
num_detections = detection_graph.get_tensor_by_name(
'num_detections:0')
(boxes, scores, classes, num_detections) = sess.run(
[boxes, scores, classes, num_detections],
feed_dict={image_tensor: frame_expanded})
ymin = int((boxes[0][0][0] * H))
xmin = int((boxes[0][0][1] * W))
ymax = int((boxes[0][0][2] * H))
xmax = int((boxes[0][0][3] * W))
box_area = (xmax - xmin) * (ymax - ymin)
total_area = W * H
# For eliminating the false positives.
if box_area > total_area * 0.5:
ymin, xmin, xmax, ymax = (None, None, None, None)
if ymin is not None:
tracker = dlib.correlation_tracker()
rect = dlib.rectangle(xmin, ymin, xmax, ymax)
tracker.start_track(rgb, rect)
trackers.append(tracker)
else:
for tracker in trackers:
self.status = "Takip Ediliyor"
tracker.update(rgb)
pos = tracker.get_position()
xmin = int(pos.left())
ymin = int(pos.top())
xmax = int(pos.right())
ymax = int(pos.bottom())
rects.append((xmin, ymin, xmax, ymax))
# cv2.line(self.frame, (W // 2, 0), (W // 2, H), (0, 255, 255), 2)
objects = ct.update(rects)
for (objectID, centroid) in objects.items():
trackable_obj = trackableObjects.get(objectID, None)
if trackable_obj is None:
trackable_obj = TrackableObject(objectID, centroid)
else:
x = [c[0] for c in trackable_obj.centroids]
direction = centroid[0] - np.mean(x)
trackable_obj.centroids.append(centroid)
if not trackable_obj.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[0] < int(
W * 0.25):
self.totalLeft += 1
trackable_obj.counted = True
elif direction > 0 and centroid[0] > int(
W * 0.75):
self.totalRight += 1
trackable_obj.counted = True
trackableObjects[objectID] = trackable_obj
text = "ID {}".format(objectID)
cv2.putText(self.frame, text,
(centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0),
2)
cv2.circle(self.frame, (centroid[0], centroid[1]), 4,
(0, 255, 0), -1)
self.signals.changeTextBox.emit(
f"{self.totalLeft}\n{self.totalRight}\n{self.status}")
# End of the loop
bytesPerLine = ch * W
convertToQtFormat = QImage(rgb.data, W, H, bytesPerLine,
QImage.Format_RGB888)
p = convertToQtFormat.scaled(800, 600, Qt.KeepAspectRatio)
self.signals.changePixmap.emit(p)
totalFrames += 1
fps.update()
#
self.signals.changeTitleBox.emit("Durum: ")
# Clear output
self.signals.changeTextBox.emit("Rapor kaydedildi.")
# Alter button to Start.
self.signals.changeButton.emit("start_button")
# Stop FPS count.
fps.stop()
# Get total elapsed time.
self.total_elapsed_time = fps.elapsed()
# Create report to database.
self.create_report(self.totalLeft, self.totalRight, fps.elapsed())
# Finally, set placeholder.
self.signals.changePixmap.emit(QImage('./Resources/placeholder2.png'))
# initialize the video writer
writer = None
#initialize the file writer
file_object = open("cv_detection_results_east.txt", "a+")
# 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=25, maxDistance=150) #was 25 and 150
trackers = []
trackableObjects = {}
#Set the time in epoch
local_time = 1564718220
time = datetime.fromtimestamp(local_time)
print('start time:', time)
# 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
temp_in = 0
temp_out = 0
class detector:
def __init__(self,
prototxt="mobilenet_ssd/MobileNetSSD_deploy.prototxt",
model="mobilenet_ssd/MobileNetSSD_deploy.caffemodel",
confidence=0.4,
skipframes=10):
print("Initiate detector...")
self.CLASSES = [
"background", "aeroplane", "bicycle", "bird", "boat", "bottle",
"bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse",
"motorbike", "person", "pottedplant", "sheep", "sofa", "train",
"tvmonitor"
]
self.confidence = confidence
self.net = cv2.dnn.readNetFromCaffe(prototxt, model)
#self.vs = VideoStream(src = 0, usePiCamera = True).start()
self.vs = VideoStream(src=0).start()
self.W = None
self.H = None
self.ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
self.trackers = []
self.trackableObjects = {}
self.totalFrames = 0
self.skipframes = skipframes
self.fps = FPS().start()
def main(self):
while True:
frame = self.vs.read()
frame = frame[1]
# frame = frame[1] if args.get("input", False) else frame
frame = imutils.resize(frame, width=250)
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
if self.W is None or self.H is None:
(self.H, self.W) = frame.shape[:2]
status = "Waiting"
rects = []
if self.totalFrames % self.skipframes == 0:
status = "Detecting"
self.trackers = []
blob = cv2.dnn.blobFromImage(frame, 0.007843, (self.W, self.H),
127.5)
self.net.setInput(blob)
detections = self.net.forward()
for i in np.arange(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
if confidence > self.confidence:
idx = int(detections[0, 0, i, 1])
if self.CLASSES[idx] != "person":
continue
box = detections[0, 0, i, 3:7] * np.array(
[self.W, self.H, self.W, self.H])
(startX, startY, endX, endY) = box.astype("int")
tracker = dlib.correlation_tracker()
rect = dlib.rectangle(startX, startY, endX, endY)
tracker.start_track(rgb, rect)
self.trackers.append(tracker)
else:
for tracker in self.trackers:
status = "Tracking"
tracker.update(rgb)
pos = tracker.get_position()
startX = int(pos.left())
startY = int(pos.top())
endX = int(pos.right())
endY = int(pos.bottom())
rects.append((startX, startY, endX, endY))
cv2.line(frame, (0, self.H // 2), (self.W, self.H // 2),
(0, 255, 255), 2)
objects = self.ct.update(rects)
for (objectID, centroid) in objects.items():
to = self.trackableObjects.get(objectID, None)
if to is None:
to = TrackableObject(objectID, centroid)
else:
y = [c[1] for c in to.centroids]
direction = centroid[1] - np.mean(y)
to.centroids.append(centroid)
if not to.counted:
if direction < 0 and centroid[1] < self.H // 2:
totalUp += 1
to.counted = True
elif direction > 0 and centroid[1] > self.H // 2:
totalDown += 1
to.counted = True
self.trackableObjects[objectID] = to
text = "ID {}".format(objectID)
cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0),
-1)
info = [
("Up", totalUp),
("Down", totalDown),
("Status", status),
]
for (i, (k, v)) in enumerate(info):
text = "{}: {}".format(k, v)
cv2.putText(frame, text, (10, self.H - ((i * 20) + 20)),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 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
# increment the total number of frames processed thus far and
# then update the FPS counter
self.totalFrames += 1
self.fps.update()
# stop the timer and display FPS information
self.fps.stop()
print("[INFO] elapsed time: {:.2f}".format(self.fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(self.fps.fps()))
self.vs.stop()
cv2.destroyAllWindows()
def tracker():
rospy.init_node("Centroid_Dist_Publisher", anonymous=True)
pub = rospy.Publisher("CentroidDistance", CentroidDist, queue_size=10)
rate = rospy.Rate(30)
centre_x = 0
centre_y = 0
# initialize our centroid tracker and frame dimensions
ct = CentroidTracker()
(H, W) = (None, None)
confidence = 0.7
# load our serialized model from disk
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe("deploy.prototxt",
"res10_300x300_ssd_iter_140000.caffemodel")
# initialize the video stream and allow the camera sensor to warmup
print("[INFO] starting video stream...")
# resource_name = "/dev/video" + resource
# resource = int(resource)
# vs = cv2.VideoCapture('rtsp://192.168.1.254/sjcam.mov')
# vs = VideoStream(src='rtsp://192.168.1.254/sjcam.mov').start()
vs = VideoStream(src=0).start()
time.sleep(2.0)
while not rospy.is_shutdown():
# loop over the frames from the video stream
while True:
# read the next frame from the video stream and resize it
# ret, frame = vs.read()
frame = vs.read()
frame = imutils.resize(frame, width=400)
# frame = cv2.resize(frame, (225,400))
# print(frame.shape)
# if the frame dimensions are None, grab them
if W is None or H is None:
(H, W) = frame.shape[:2]
# construct a blob from the frame, pass it through the network,
# obtain our output predictions, and initialize the list of
# bounding box rectangles
blob = cv2.dnn.blobFromImage(frame, 1.0, (W, H),
(104.0, 177.0, 123.0))
# fps = video.get(cv2.CAP_PROP_FPS)
net.setInput(blob)
detections = net.forward()
rects = []
# loop over the detections
for i in range(0, detections.shape[2]):
# if len(detections[2]) == 1:
# filter out weak detections by ensuring the predicted
# probability is greater than a minimum threshold
if detections[0, 0, i, 2] > confidence:
# compute the (x, y)-coordinates of the bounding box for
# the object, then update the bounding box rectangles list
box = detections[0, 0, i, 3:7] * np.array([W, H, W, H])
rects.append(box.astype("int"))
# draw a bounding box surrounding the object so we can
# visualize it
(startX, startY, endX, endY) = box.astype("int")
cv2.rectangle(frame, (startX, startY), (endX, endY),
(0, 255, 0), 2)
midX = (startX + endX) / 2
midY = (startY + endY) / 2
# update our centroid tracker using the computed set of bounding
# box rectangles
objects = ct.update(rects)
c = 0
# loop over the tracked objects
for (objectID, centroid) in objects.items():
CDist = CentroidDist()
# 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, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0),
-1)
# print(centroid[0], centroid[1])
# print("\n\n")
centre_x += (200 - centroid[0])
centre_y += (112 - centroid[1])
c = c + 1
# print(200 - centroid[0], 150 - centroid[1])
# # print("\n")
# print "Frames per second using video.get(cv2.CAP_PROP_FPS) : {0}".format(fps)
# if(centroid[0]>220):
# com ="Move Left"
# elif(centroid[0]<180):
# com ="Move Right"
# else:
# if centroid[1] > 220:
# com = "Move Down"
# elif centroid[1] < 180:
# com = "Move Up"
# else:
# com = "Centered!"
object_count = "Count: {}".format(len(objects.items()))
cv2.putText(frame, object_count, (300, 290),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
# show the output frame
# cv2.putText(frame, fps, (140,20),
# cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
if c != 0:
CDist.dx = centre_x / c
CDist.dy = centre_y / c
else:
CDist.dx = 0
CDist.dy = 0
pub.publish(CDist)
centre_x = 0
centre_y = 0
c = 0
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# if the ` ` key was pressed, break from the loop
if key == ord(" "):
break
rate.sleep()
# do a bit of cleanup
#cv2.destroyAllWindows()
vs.stop()
def main_process(self):
Base={
"max_disappear": 30,
"max_distance": 200,
"track_object": 4,
"confidence": 0.4,
"frame_height": 400,
"line_point" : 125,
"display": "true",
"model_path": "MobileNetSSD_deploy.caffemodel",
"prototxt_path": "MobileNetSSD_deploy.prototxt",
"output_path": "output",
"csv_name": "log.csv"
}
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
"bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
"dog", "horse", "motorbike", "person", "pottedplant", "sheep",
"sofa", "train", "tvmonitor"]
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(Base["prototxt_path"],
Base["model_path"])
print("[INFO] warming up camera...")
vs = cv2.VideoCapture(self.filename)
H = None
W = None
ct = CentroidTracker(maxDisappeared=Base["max_disappear"],
maxDistance=Base["max_distance"])
trackers = []
trackableObjects = {}
totalFrames = 0
logFile = None
points = [("A", "B"), ("B", "C"), ("C", "D")]
fps = FPS().start()
while True:
ret, frame = vs.read()
ts = datetime.now()
newDate = ts.strftime("%m-%d-%y")
minut=ts.minute
if frame is None:
break
frame = imutils.resize(frame, height=Base["frame_height"])
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
if W is None or H is None:
(H, W) = frame.shape[:2]
rects = []
if totalFrames % Base["track_object"] == 0:
trackers = []
blob = cv2.dnn.blobFromImage(frame, size=(300, 300),
ddepth=cv2.CV_8U)
net.setInput(blob, scalefactor=1.0/127.5, mean=[127.5,
127.5, 127.5])
detections = net.forward()
# loop over the detections
for i in np.arange(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
if confidence > Base["confidence"]:
idx = int(detections[0, 0, i, 1])
if CLASSES[idx] != "car":
if CLASSES[idx] != "bus":
if CLASSES[idx] != "motorbike":
continue
box = detections[0, 0, i, 3:7] * np.array([W, H, W, H])
(startX, startY, endX, endY) = box.astype("int")
tracker = dlib.correlation_tracker()
rect = dlib.rectangle(int(startX), int(startY), int(endX), int(endY))
tracker.start_track(rgb, rect)
cv2.rectangle(frame, (startX, startY), (endX, endY), (0,225,0), 4)
trackers.append(tracker)
else:
for tracker in trackers:
tracker.update(rgb)
pos = tracker.get_position()
startX = int(pos.left())
startY = int(pos.top())
endX = int(pos.right())
endY = int(pos.bottom())
cv2.rectangle(frame, (startX, startY), (endX, endY), (0,225,0), 4)
rects.append((startX, startY, endX, endY))
objects = ct.update(rects)
for (objectID, centroid) in objects.items():
to = trackableObjects.get(objectID, None)
if to is None:
to = TrackableObject(objectID, centroid)
elif not to.estimated:
y = [c[1] for c in to.centroids]
direction = centroid[1] - np.mean(y)
to.direction = direction
if(to.direction>0):
tet = "down"
cv2.putText(frame, tet, (centroid[0] - 10, centroid[1] - 20)
, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
if minut%2==0:
if not to.belowline:
if(centroid[1] < self.line_point):
to.belowline = "F"
else:
to.belowline = "T"
else:
if(to.belowline == "F" and centroid[1] > self.line_point):
if not to.savethefile:
#crop = frame[startX:endX, startY:endY]
cv2.imwrite('output/violation'+str(self.saveno)+'.jpg', frame)
to.savethefile = 1
self.saveno += 1
cv2.circle(frame, (centroid[0]+10, centroid[1]), 4,
(0, 0, 255), -1)
else:
if to.belowline:
to.belowline = None
elif(to.direction<0):
tet = "up"
cv2.putText(frame, tet, (centroid[0] - 10, centroid[1] - 20)
, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
elif(to.direction==0):
tet = "stationary"
cv2.putText(frame, tet, (centroid[0] - 10, centroid[1] - 20)
, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
trackableObjects[objectID] = to
text = "ID {}".format(objectID)
cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10)
, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4,
(0, 255, 0), -1)
if minut%2==0:
cv2.line(frame, (0, self.line_point), (2000, self.line_point), (0,0,255), 4)
else:
cv2.line(frame, (0, self.line_point), (2000, self.line_point), (0,255,0), 4)
if Base["display"]=="true":
cv2.imshow("frame", frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
totalFrames += 1
fps.update()
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
cv2.destroyAllWindows()
vs.release()
def main():
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--prototxt", required=True,
help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m", "--model", required=True,
help="path to Caffe pre-trained model")
ap.add_argument("-c", "--confidence", type=float, default=0.5,
help="minimum probability to filter weak detections")
ap.add_argument("--fps",type=int, default=15,
help="frame rate")
ap.add_argument("-a", "--min-area", type=int, default=500,
help="minimum area size")
ap.add_argument("-i","--motion-tracking",type=bool,default=True,
help="Enable motion tracking")
ap.add_argument("-o", "--object-tracking", type=bool, default=True,
help="Enable selectable object tracking")
ap.add_argument("-t","--tracker",type=str,default="kcf",
help="Tracker type for object tracking")
ap.add_argument("-f", "--facial_recog", type=bool, default=True,
help="Facial Recognition Tracking")
args = vars(ap.parse_args())
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
if args['facial_recog']:
(H, W) = (None, None)
# initialize our centroid tracker and frame dimensions
ct = CentroidTracker()
# load our serialized model from disk
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# initialize the video stream and allow the camera sensor to warmup
if args['motion_tracking']:
firstFrame=None
if args["object_tracking"]:
initBB = None
# extract the OpenCV version info
(major, minor) = cv2.__version__.split(".")[:2]
# if we are using OpenCV 3.2 OR BEFORE, we can use a special factory
# function to create our object tracker
if int(major) == 3 and int(minor) < 3:
tracker = cv2.Tracker_create(args["tracker"].upper())
# otherwise, for OpenCV 3.3 OR NEWER, we need to explicity call the
# approrpiate object tracker constructor:
else:
OPENCV_OBJECT_TRACKERS = {
"csrt": cv2.TrackerCSRT_create,
"kcf": cv2.TrackerKCF_create,
"boosting": cv2.TrackerBoosting_create,
"mil": cv2.TrackerMIL_create,
"tld": cv2.TrackerTLD_create,
"medianflow": cv2.TrackerMedianFlow_create,
"mosse": cv2.TrackerMOSSE_create
}
tracker = OPENCV_OBJECT_TRACKERS[args["tracker"]]()
while True:
st=time.time()
#read the next frame from the video stream and resize it
frame = vs.read()
frame = imutils.resize(frame, width=400)
if args['motion_tracking']:
firstFrame=motionTracker(frame.copy(),firstFrame,args["min_area"])
if args['object_tracking']:
initBB=objectTracker(frame.copy(),initBB,tracker)
if args['facial_recog']:
W,H = facialRecogTracker(frame.copy(),net,ct,W,H,args["confidence"])
sleepTime = (1 / args['fps'])-(time.time()-st)
if sleepTime > 0:
time.sleep(sleepTime)
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 video_feed_counter(conf, mode, input, output, url, camera):
# construct the argument parser and parse the arguments
# load the configuration file
conf = Conf(conf)
count = 0
# initialize the MOG foreground background subtractor object
# mog = cv2.bgsegm.createBackgroundSubtractorMOG()
mog = cv2.createBackgroundSubtractorMOG2()
# initialize and define the dilation kernel
dKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
# initialize the video writer process
writerProcess = 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 and initialize a dictionary to
# map each unique object ID to a trackable object
ct = CentroidTracker(conf["max_disappeared"], conf["max_distance"])
trackableObjects = {}
# if a video path was not supplied, grab a reference to the webcam
# if not args.get("input", False):
# if input:
# print("[INFO] starting video stream...")
# # vs = VideoStream(src=0).start()
# vs = VideoStream(usePiCamera=True).start()
# time.sleep(2.0)
# otherwise, grab a reference to the video file
# else:
print("[INFO] opening video file...")
vs = cv2.VideoCapture(url, cv2.CAP_FFMPEG)
# vs = cv2.VideoCapture(args["input"])
# check if the user wants to use the difference flag feature
if conf["diff_flag"]:
# initialize the start counting flag and mouse click callback
start = False
cv2.namedWindow("set_points")
cv2.setMouseCallback("set_points", set_points, [mode])
# otherwise, the user does not want to use it
else:
# set the start flag as true indicating to start traffic counting
start = True
# initialize the direction info variable (used to store information
# such as up/down or left/right vehicle count) and the difference
# point (used to differentiate between left and right lanes)
directionInfo = None
diffPt = None
fps = FPS().start()
# print('fbs')
# loop over frames from the video stream
while (vs.isOpened()):
# grab the next frame and handle if we are reading from either
# VideoCapture or VideoStream
# frame = vs.read()
ret, frame = vs.read() # import image
# if not ret:
# frame = cv2.VideoCapture(url)
# continue
# if ret:
# frame = cv2.VideoCapture(url)
# continue
# if we are viewing a video and we did not grab a frame then we
# have reached the end of the video
if input is not None and frame is None:
break
#print("frame in while")
# check if the start flag is set, if so, we will start traffic
# counting
if start:
# if the frame dimensions are empty, grab the frame
# dimensions, instantiate the direction counter, and set the
# centroid tracker direction
if W is None or H is None:
# start the frames per second throughput estimator
#fps = FPS().start()
(H, W) = frame.shape[:2]
dc = DirectionCounter(mode, W - conf["x_offset"],
H - conf["y_offset"])
ct.direction = mode
# check if the difference point is set, if it is, then
# set it in the centroid tracker object
if diffPt is not None:
ct.diffPt = diffPt
# begin writing the video to disk if required
if output is not None and writerProcess is None:
# set the value of the write flag (used to communicate when
# to stop the process)
writeVideo = Value('i', 1)
# initialize a shared queue for the exhcange frames,
# initialize a process, and start the process
frameQueue = Queue()
writerProcess = Process(target=write_video,
args=(output, writeVideo, frameQueue,
W, H))
writerProcess.start()
# initialize a list to store the bounding box rectangles
# returned by background subtraction model
rects = []
# convert the frame to grayscale image and then blur it
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (5, 5), 0)
# apply the MOG background subtraction model which returns
# a mask
mask = mog.apply(gray)
# apply dilation
dilation = cv2.dilate(mask, dKernel, iterations=2)
# find contours in the mask
cnts = cv2.findContours(dilation.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
# loop over each contour
for c in cnts:
# if the contour area is less than the minimum area
# required then ignore the object
if cv2.contourArea(c) < conf["min_area"]:
continue
# get the (x, y)-coordinates of the contour, along with
# height and width
(x, y, w, h) = cv2.boundingRect(c)
# check if direction is *vertical and the vehicle is
# further away from the line, if so then, no need to
# detect it
if mode == "vertical" and y < conf["limit"]:
continue
# otherwise, check if direction is horizontal and the
# vehicle is further away from the line, if so then,
# no need to detect it
elif mode == "horizontal" and x > conf["limit"]:
continue
# add the bounding box coordinates to the rectangles list
rects.append((x, y, x + w, y + h))
# check if the direction is vertical
if mode == "vertical":
# draw a horizontal line in the frame -- once an object
# crosses this line we will determine whether they were
# moving 'up' or 'down'
cv2.line(frame, (0, H - conf["y_offset"]),
(W, H - conf["y_offset"]), (0, 255, 255), 2)
# check if a difference point has been set, if so, draw
# a line diving the two lanes
if diffPt is not None:
cv2.line(frame, (diffPt, 0), (diffPt, H), (255, 0, 0), 2)
# otherwise, the direction is horizontal
else:
# draw a vertical line in the frame -- once an object
# crosses this line we will determine whether they were
# moving 'left' or 'right'
# print('ddds')
cv2.line(frame, (W - conf["x_offset"], 0),
(W - conf["x_offset"], H), (0, 255, 255), 2)
# check if a difference point has been set, if so, draw a
# line dividing the two lanes
if diffPt is not None:
cv2.line(frame, (0, diffPt), (W, diffPt), (255, 0, 0), 2)
# 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 and initialize the color
to = trackableObjects.get(objectID, None)
color = (0, 0, 255)
# create a new trackable object if needed
if to is None:
to = TrackableObject(objectID, centroid)
# otherwise, there is a trackable object so we can
# utilize it to determine direction
else:
# find the direction and update the list of centroids
dc.find_direction(to, centroid)
to.centroids.append(centroid)
# check to see if the object has been counted or not
if not to.counted:
# find the direction of motion of the vehicles
directionInfo = dc.count_object(to, centroid, camera)
# otherwise, the object has been counted and set the
# color to green indicate it has been counted
else:
color = (0, 255, 0)
# 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, color, 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, color, -1)
# extract the traffic counts and write/draw them
if directionInfo is not None:
for (i, (k, v)) in enumerate(directionInfo):
text = "{}: {}".format(k, v)
cv2.putText(frame, text, (10, ((i * 20) + 20)),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
# put frame into the shared queue for video writing
if writerProcess is not None:
frameQueue.put(frame)
# show the output frame
# cv2.imshow("Frame", frame)
frames = cv2.imencode('.jpg', frame)[1].tobytes()
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frames + b'\r\n')
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
# update the FPS counter
fps.update()
# otherwise, the user has to select a difference point
else:
# show the output frame
# cv2.imshow("set_points", frame)
frames = cv2.imencode('.jpg', frame)[1].tobytes()
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frames + b'\r\n')
key = cv2.waitKey(1) & 0xFF
# if the `s` key was pressed, start traffic counting
if key == ord("s"):
# begin counting and eliminate the informational window
start = True
cv2.destroyWindow("set_points")
# 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()))
# terminate the video writer process
if writerProcess is not None:
writeVideo.value = 0
writerProcess.join()
# 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 main():
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
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")
ap.add_argument(
"-m",
"--model",
type=str,
default="yolov3",
help="which model to use for detection: ssd_caffe, ssd_tf, yolov3")
ap.add_argument("-t",
"--tracker",
type=str,
default="cv2",
help="which tracker to use: cv2 or dlib")
args = vars(ap.parse_args())
if args["model"] == "yolov3":
model = MLObjectDetectionModelYolov3.Load()
elif args["model"] == "ssd_caffe":
model = MLObjectDetectionModelCaffe.Load()
elif args["model"] == "ssd_tf":
model = MLObjectDetectionModelTF.Load()
# if a video path was not supplied, grab a reference to the webcam
if not args.get("input", False):
print("[INFO] starting video stream...")
vs = VideoReader(0)
# otherwise, grab a reference to the video file
else:
print("[INFO] opening video file...")
vs = VideoReader(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)
frameWidth = None
frameHeight = 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 = {}
countMap = defaultdict(lambda: 0)
# start the frames per second throughput estimator
fps = FPS().start()
totalFrames = 0
totalDown = 0
totalUp = 0
# loop over frames from the video stream
while True:
# grab the next frame and handle
frameNDArray = vs.get_frame()
if frameNDArray is None:
break
# resize the frame,
# then convert the frame from BGR to RGB for dlib
scale_percent = 60 # percent of original size
# resize image
frameNDArray = frameNDArray.resizeToScalePercent(scale_percent)
rgbFrame = frameNDArray.rgbFrame
# if the frame dimensions are empty, set them
if frameWidth is None or frameHeight is None:
(frameHeight, frameWidth) = frameNDArray.frame_height_width
# if we are supposed to be writing a video to disk, initialize
# the writer
if args["output"] is not None and writer is None:
writer = VideoWriter(args["output"], (frameWidth, frameHeight))
# initialize the list of bounding
# box rectangles returned by either (1) our object detector or
# (2) the correlation trackers
rects = []
tracker_type = args["tracker"]
# check to see if we should run a more computationally expensive
# object detection method to aid our tracker
track_classes = ["person"]
if totalFrames % skip_frames == 0:
if args["model"] == "yolov3":
trackers = frameNDArray.detectNewObjectsYolov3(
frameWidth, frameHeight, model, countMap, track_classes)
elif args["model"] == "ssd_caffe":
trackers = frameNDArray.detectNewObjectsSSDMobileNetCaffe(
frameWidth, frameHeight, model, countMap, track_classes)
elif args["model"] == "ssd_tf":
trackers = frameNDArray.detectNewObjectsSSDMobileNetTF(
frameWidth, frameHeight, model, countMap, track_classes)
# 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:
# update the tracker and grab the updated position
tracker.update(rgbFrame)
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'
frameNDArray.drawHorizontalLineInCenter()
# 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] < frameHeight // 2:
totalUp += 1
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] > frameWidth // 2:
totalDown += 1
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(frameNDArray.frame, text,
(centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.circle(frameNDArray.frame, (centroid[0], centroid[1]), 4,
(0, 255, 0), -1)
#construct a tuple of information we will be displaying on the frame
info = [("Up", totalUp), ("Down", totalDown)]
#loop over the info tuples and draw them on our frame
for (i, (k, v)) in enumerate(info):
text = "{}: {}".format(k, v)
cv2.putText(frameNDArray.frame, text,
(10, frameHeight - ((i * 20) + 20)),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
# check to see if we should write the frame to disk
if writer is not None:
writer.write(frameNDArray.frame)
# show the output frame
cv2.imshow("Frame", frameNDArray.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()
# 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()))
# check to see if we need to release the video writer pointer
if writer is not None:
writer.release()
vs.release()
# close any open windows
cv2.destroyAllWindows()
class SpeedEstimator:
# class constructor
def __init__(self, keys, videoSource):
# inform the user about framerates and speeds
print("[INFO] NOTE: When using an input video file, speeds will be " \
"inaccurate because OpenCV can't throttle FPS according to the " \
"framerate of the video. This script is for development purposes " \
"only.")
# passed values.
self.keys = keys
self.conf = json.loads(keys.json_string)
# initialize the list of class labels MobileNet SSD was trained to detect
self.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
print("[INFO] loading model...")
self.net = cv2.dnn.readNetFromCaffe(self.conf["prototxt_path"],
self.conf["model_path"])
# initialize the video stream and allow the camera sensor to warmup
print("[INFO] warming up camera...")
self.vs = cv2.VideoCapture(videoSource)
# passing the main executing thread for some period of time.
time.sleep(1.0)
# 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
# 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
self.ct = CentroidTracker(maxDisappeared=self.conf["max_disappear"],
maxDistance=self.conf["max_distance"])
self.trackers = []
self.trackableObjects = {}
# keep the count of total number of frames
self.totalFrames = 0
# initialize the log file
self.logFile = None
# initialize the list of various points used to calculate the avg of the vehicle speed
self.points = [("A", "B"), ("B", "C"), ("C", "D")]
# function responsible for starting the frames per second throughput estimator.
def startFPS(self):
self.fps = FPS().start()
# function for creating a log file, if it does not exist.
def createLogFileIfNotExist(self):
# if the log file has not been created or opened
if self.logFile is None:
# build the log file path and create/open the log file
self.logPath = os.path.join(self.conf["output_path"],
self.conf["csv_name"])
self.logFile = open(logPath, mode="a")
# set the file pointer to end of the file
pos = self.logFile.seek(0, os.SEEK_END)
# if using an empty log file then
# write the column headings
if pos == 0:
self.logFile.write(
"Year,Month,Day,Time,Speed (in MPH),ImageID\n")
# function for determining the type of algorithm to use in detecting
# vehicle speed.
def runComputationallyTaskingAlgoIfBasicAlgoFails(self):
# check to see if we should run a more computationally expensive
# object detection method to aid our tracker
if self.totalFrames % self.conf["track_object"] == 0:
# initialize our new set of object trackers
self.trackers = []
# convert the frame to a blob and pass the blob through the
# network and obtain the detections
blob = cv2.dnn.blobFromImage(frame,
size=(300, 300),
ddepth=cv2.CV_8U)
self.net.setInput(blob,
scalefactor=1.0 / 127.5,
mean=[127.5, 127.5, 127.5])
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.conf["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 car, ignore it
if self.CLASSES[idx] != "car":
continue
# compute the (x, y)-coordinates of the bounding box
# for the object
box = detections[0, 0, i, 3:7] * np.array(
[self.W, self.H, self.W, self.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(self.rgb, rect)
# add the tracker to our list of trackers so we can
# utilize it during skip frames
self.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 self.trackers:
# update the tracker and grab the updated position
tracker.update(self.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
self.rects.append((startX, startY, endX, endY))
# function for passing tempFile created, along with other
# metadata.
def upload_file(tempFile, client, imageID):
# upload the image to Dropbox and cleanup the tempory image
print("[INFO] uploading {}...".format(imageID))
path = "/{}.jpg".format(imageID)
client.files_upload(open(tempFile.path, "rb").read(), path)
tempFile.cleanup()
# program loop.
def programLoop(self):
while True:
# grab the next frame from the stream, store the current
# timestamp, and store the new date
self.ret, self.frame = self.vs.read()
self.ts = datetime.now()
newDate = self.ts.strftime("%m-%d-%y")
# check if the frame is None, if so, break out of the loop
if (self.frame is None):
# break
return
# if the log file has not been created or opened
self.createLogFileIfNotExist()
# resize the frame
self.frame = imutils.resize(self.frame,
width=self.conf["frame_width"])
self.rgb = cv2.cvtColor(self.frame, cv2.COLOR_BGR2RGB)
# if the frame dimensions are empty, set them
if ((self.W is None) or (self.H is None)):
(self.H, self.W) = self.frame.shape[:2]
self.meterPerPixel = self.conf["distance"] / self.W
# initialize our list of bounding box rectangles returned by
# either (1) our object detector or (2) the correlation trackers
rects = []
runComputationallyTaskingAlgoIfBasicAlgoFails()
objects = self.ct.update(self.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 = self.trackableObjects.get(objectID, None)
# if there is no existing trackable object, create one
if to is None:
to = TrackableObject(objectID, centroid)
# otherwise, if there is a trackable object and its speed has
# not yet been estimated then estimate it
elif not to.estimated:
# check if the direction of the object has been set, if
# not, calculate it, and set it
if to.direction is None:
y = [c[0] for c in to.centroids]
direction = centroid[0] - np.mean(y)
to.direction = direction
# if the direction is positive (indicating the object
# is moving from left to right)
if to.direction > 0:
# check to see if timestamp has been noted for
# point A
if to.timestamp["A"] == 0:
# if the centroid's x-coordinate is greater than
# the corresponding point then set the timestamp
# as current timestamp and set the position as the
# centroid's x-coordinate
if centroid[0] > self.conf[
"speed_estimation_zone"]["A"]:
to.timestamp["A"] = self.ts
to.position["A"] = centroid[0]
# check to see if timestamp has been noted for
# point B
elif to.timestamp["B"] == 0:
# if the centroid's x-coordinate is greater than
# the corresponding point then set the timestamp
# as current timestamp and set the position as the
# centroid's x-coordinate
if centroid[0] > self.conf[
"speed_estimation_zone"]["B"]:
to.timestamp["B"] = self.ts
to.position["B"] = centroid[0]
# check to see if timestamp has been noted for
# point C
elif to.timestamp["C"] == 0:
# if the centroid's x-coordinate is greater than
# the corresponding point then set the timestamp
# as current timestamp and set the position as the
# centroid's x-coordinate
if centroid[0] > self.conf[
"speed_estimation_zone"]["C"]:
to.timestamp["C"] = self.ts
to.position["C"] = centroid[0]
# check to see if timestamp has been noted for
# point D
elif to.timestamp["D"] == 0:
# if the centroid's x-coordinate is greater than
# the corresponding point then set the timestamp
# as current timestamp, set the position as the
# centroid's x-coordinate, and set the last point
# flag as True
if centroid[0] > self.conf[
"speed_estimation_zone"]["D"]:
to.timestamp["D"] = self.ts
to.position["D"] = centroid[0]
to.lastPoint = True
# if the direction is negative (indicating the object
# is moving from right to left)
elif to.direction < 0:
# check to see if timestamp has been noted for
# point D
if to.timestamp["D"] == 0:
# if the centroid's x-coordinate is lesser than
# the corresponding point then set the timestamp
# as current timestamp and set the position as the
# centroid's x-coordinate
if centroid[0] < self.conf[
"speed_estimation_zone"]["D"]:
to.timestamp["D"] = self.ts
to.position["D"] = centroid[0]
# check to see if timestamp has been noted for
# point C
elif to.timestamp["C"] == 0:
# if the centroid's x-coordinate is lesser than
# the corresponding point then set the timestamp
# as current timestamp and set the position as the
# centroid's x-coordinate
if centroid[0] < self.conf[
"speed_estimation_zone"]["C"]:
to.timestamp["C"] = self.ts
to.position["C"] = centroid[0]
# check to see if timestamp has been noted for
# point B
elif to.timestamp["B"] == 0:
# if the centroid's x-coordinate is lesser than
# the corresponding point then set the timestamp
# as current timestamp and set the position as the
# centroid's x-coordinate
if centroid[0] < self.conf[
"speed_estimation_zone"]["B"]:
to.timestamp["B"] = self.ts
to.position["B"] = centroid[0]
# check to see if timestamp has been noted for
# point A
elif to.timestamp["A"] == 0:
# if the centroid's x-coordinate is lesser than
# the corresponding point then set the timestamp
# as current timestamp, set the position as the
# centroid's x-coordinate, and set the last point
# flag as True
if centroid[0] < self.conf[
"speed_estimation_zone"]["A"]:
to.timestamp["A"] = self.ts
to.position["A"] = centroid[0]
to.lastPoint = True
# check to see if the vehicle is past the last point and
# the vehicle's speed has not yet been estimated, if yes,
# then calculate the vehicle speed and log it if it's
# over the limit
if to.lastPoint and not to.estimated:
# initialize the list of estimated speeds
estimatedSpeeds = []
# loop over all the pairs of points and estimate the
# vehicle speed
for (i, j) in self.points:
# calculate the distance in pixels
d = to.position[j] - to.position[i]
distanceInPixels = abs(d)
# check if the distance in pixels is zero, if so,
# skip this iteration
if distanceInPixels == 0:
continue
# calculate the time in hours
t = to.timestamp[j] - to.timestamp[i]
timeInSeconds = abs(t.total_seconds())
timeInHours = timeInSeconds / (60 * 60)
# calculate distance in kilometers and append the
# calculated speed to the list
distanceInMeters = distanceInPixels * self.meterPerPixel
distanceInKM = distanceInMeters / 1000
estimatedSpeeds.append(distanceInKM / timeInHours)
# calculate the average speed
to.calculate_speed(estimatedSpeeds)
# set the object as estimated
to.estimated = True
print("[INFO] Speed of the vehicle that just passed" \
" is: {:.2f} MPH".format(to.speedMPH))
# store the trackable object in our dictionary
self.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(self.frame, text,
(centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.circle(self.frame, (centroid[0], centroid[1]), 4,
(0, 255, 0), -1)
# check if the object has not been logged
if not to.logged:
# check if the object's speed has been estimated and it
# is higher than the speed limit
if to.estimated and to.speedMPH > self.conf["speed_limit"]:
# set the current year, month, day, and time
year = self.ts.strftime("%Y")
month = self.ts.strftime("%m")
day = self.ts.strftime("%d")
time = self.ts.strftime("%H:%M:%S")
# check if dropbox is to be used to store the vehicle
# image
if self.conf["use_dropbox"]:
# initialize the image id, and the temporary file
imageID = self.ts.strftime("%H%M%S%f")
tempFile = TempFile()
cv2.imwrite(tempFile.path, self.frame)
# create a thread to upload the file to dropbox
# and start it
t = Thread(target=upload_file,
args=(
tempFile,
client,
imageID,
))
t.start()
# log the event in the log file
info = "{},{},{},{},{},{}\n".format(
year, month, day, time, to.speedMPH, imageID)
self.logFile.write(info)
# otherwise, we are not uploading vehicle images to
# dropbox
else:
# log the event in the log file
info = "{},{},{},{},{}\n".format(
year, month, day, time, to.speedMPH)
self.logFile.write(info)
# set the object has logged
to.logged = True
# # if the *display* flag is set, then display the current frame
# to the screen and record if a user presses a key
if self.conf["display"]:
cv2.imshow("frame", self.frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key is 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
self.totalFrames += 1
self.fps.update()
# stop the timer and display FPS information
self.fps.stop()
print("[INFO] elapsed time: {:.2f}".format(self.fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(self.fps.fps()))
def closeLogFile(self):
# check if the log file object exists, if it does, then close it
if self.logFile is not None:
self.logFile.close()
# destroying all used resources.
def destroyUsedResources(self):
# close any open windows
cv2.destroyAllWindows()
# clean up
print("[INFO] cleaning up...")
self.vs.release()
def main(self):
# starting FPS.
self.startFPS()
# running program, loop.
self.programLoop()
# closing the log file
self.closeLogFile()
# destroying all used resources
destroyUsedResources()
else:
output_count += 1
print("[INFO] output directory: ", writer_path)
# инициализируем размеры кадра как пустые значения
# они будут переназначены при анализе первого кадра и только
# это ускорит работу программы
width = None
height = None
# инициализируем алгоритм трекинга
# maxDisappeared = кол-во кадров, на которое объект может исчезнуть с видео и потом опять
# будет распознан
# maxDistance = максимальное расстояние между центрами окружностей, вписанных в боксы машин
# Если расстояние меньше заданного, то происходит переприсваение ID
car_ct = CentroidTracker()
car_ct.maxDisappeared = 10
person_ct = CentroidTracker()
person_ct.maxDisappeared = 10
truck_ct = CentroidTracker()
truck_ct.maxDisappeared = 10
bike_ct = CentroidTracker()
bike_ct.maxDisappeared = 10
bicycle_ct = CentroidTracker()
bicycle_ct.maxDisappeared = 10
bus_ct = CentroidTracker()
bus_ct.maxDisappeared = 10
# сам список трекеров
trackers = []
# список объектов для трекинга
colors = np.random.uniform(0, 255, size=(len(classes), 3))
#cap=cv2.VideoCapture("/home/giuser/249_248_Source_backup/vehical_count/outpy.avi") #0 for 1st webcam
cap = cv2.VideoCapture()
font = cv2.FONT_HERSHEY_SIMPLEX
starting_time = time.time()
frame_id = 0
# frame_width = int(cap.get(3))
# frame_height = int(cap.get(4))
out_ = cv2.VideoWriter('outpy_testing.avi',
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 1,
(1200, 678))
ct = CentroidTracker()
trackers = []
trackableObjects = {}
totalFrames = 0
totalDown = 0
totalUp = 0
x_ = []
empty = []
empty1 = []
#################### In out thresold logic #####################
OUT = 320 # old 340
IN = 580
middle_cut_X = 575
middle_cut_Y = 150
else:
i += 1
print("[INFO] output directory: ", writer_path)
# инициализируем размеры кадра как пустые значения
# они будут переназначены при анализе первого кадра и только
# это ускорит работу программы
width = None
height = None
# инициализируем алгоритм трекинга
# maxDisappeared = кол-во кадров, на которое объект может исчезнуть с видео и потом опять
# будет распознан
# maxDistance = максимальное расстояние между центрами окружностей, вписанных в боксы машин
# Если расстояние меньше заданного, то происходит переприсваение ID
ct = CentroidTracker()
# сам список трекеров
trackers = []
# список объектов для трекинга
trackableObjects = {}
# полное число кадров в видео
totalFrames = 0
# счетчик машин и временная переменная
total = 0
temp = None
# статус: распознавание или отслеживание
status = None
def getRealTimePeopleCount():
try:
CLASSES = ["person"]
# Grab path to current working directory
CWD_PATH = os.getcwd()
OUTPUT_DIRECTORY = 'output'
MODEL_DIRECTORY = 'inference_graph'
PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_DIRECTORY,
'frozen_inference_graph.pb')
output = os.path.join(CWD_PATH, OUTPUT_DIRECTORY, 'example_01.avi')
input = os.path.join(CWD_PATH, 'videos', 'example_01.avi')
input = None
defaultConfidence = 0.4
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
print("[INFO] loading model...")
# if a video path was not supplied, grab a reference to the webcam
if input is None:
print("[INFO] starting video stream...")
vs = VideoStream(
src='rtsp://*****:*****@[email protected]').start()
time.sleep(2.0)
# otherwise, grab a reference to the video file
else:
print("[INFO] opening video file...")
vs = cv2.VideoCapture(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
peopleCount = 0
# 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()
frame = frame[1] if input is not None 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 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
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 output is not None and writer is None:
fourcc = cv2.VideoWriter_fourcc(*"MJPG")
writer = cv2.VideoWriter(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
rects = []
# check to see if we should run a more computationally expensive
# object detection method to aid our tracker
if totalFrames % 30 == 0:
trackers = []
rows = frame.shape[0]
cols = frame.shape[1]
inp = cv2.resize(frame, (300, 300))
inp = inp[:, :, [2, 1, 0]] # BGR2RGB
out = sess.run(
[
sess.graph.get_tensor_by_name('num_detections:0'),
sess.graph.get_tensor_by_name('detection_scores:0'),
sess.graph.get_tensor_by_name('detection_boxes:0'),
sess.graph.get_tensor_by_name('detection_classes:0')
],
feed_dict={
'image_tensor:0':
inp.reshape(1, inp.shape[0], inp.shape[1], 3)
})
# Visualize detected bounding boxes.
num_detections = int(out[0][0])
for i in range(num_detections):
classId = int(out[3][0][i])
classId -= 1
score = float(out[1][0][i])
bbox = [float(v) for v in out[2][0][i]]
if score > defaultConfidence:
startX = int(bbox[1] * cols)
startY = int(bbox[0] * rows)
endX = int(bbox[3] * cols)
endY = int(bbox[2] * rows)
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)
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))
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
peopleCount += 1
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
# 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, (0, 255, 0), 2)
cv2.rectangle(frame, ((centroid[0] - 30, centroid[1] - 40)),
((centroid[0] + 30, centroid[1] + 40)),
(0, 255, 0), 1)
# construct a tuple of information we will be displaying on the
# frame
info = [("PeopleCount", peopleCount)]
# loop over the info tuples and draw them on our frame
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, 255), 2)
# check to see if we should write the frame to disk
if writer is not None:
writer.write(frame)
# 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
# increment the total number of frames processed thus far and
# then update the FPS counter
totalFrames += 1
fps.update()
# stop the timer and display FPS information
fps.stop()
outputVideoUrl = "localhost:8000/static/videos/example_01.avi"
print("PeopleCount", peopleCount)
print("outputVideoUrl", outputVideoUrl)
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
# check to see if we need to release the video writer pointer
if writer is not None:
writer.release()
# if we are not using a video file, stop the camera video stream
if input is None:
vs.stop()
# otherwise, release the video file pointer
else:
vs.release()
# close any open windows
cv2.destroyAllWindows()
return (peopleCount, outputVideoUrl)
except Exception as ex:
traceback.print_exc()
raise ex
if args["mask"] is not None:
try:
x_min, y_min, x_max, y_max = [
int(item.replace(" ", "")) for item in args["mask"].split(",")
]
observation_mask = [(x_min, y_min), (x_max, y_max)]
except ValueError:
print("Invalid mask format!")
# 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
centroidTracker_max_disappeared = 15
centroidTracker_max_distance = 100
ct = CentroidTracker(maxDisappeared=centroidTracker_max_disappeared,
maxDistance=centroidTracker_max_distance,
mask=observation_mask)
trackers = []
trackableObjects = {}
# Load the model
#net = cv2.dnn.readNet('models/mobilenet-ssd/FP16/mobilenet-ssd.xml', 'models/mobilenet-ssd/FP16/mobilenet-ssd.bin')
net = cv2.dnn.readNetFromCaffe("models/MobileNetSSD_deploy.prototxt",
"models/MobileNetSSD_deploy.caffemodel")
# Specify target device
#net.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD)
# if a video path was not supplied, grab a reference to the webcam
if not args.get("input", False):
print("[INFO] starting video stream...")
config = tf.compat.v1.ConfigProto()
#config.gpu_options.per_process_gpu_memory_fraction = 0.8
config.gpu_options.allow_growth = True
sess = tf.compat.v1.Session(config=config)
flags.DEFINE_string('classes', './data/coco.names', 'path to classes file')
flags.DEFINE_string('weights', './checkpoints/yolov3.tf',
'path to weights file')
flags.DEFINE_boolean('tiny', False, 'yolov3 or yolov3-tiny')
flags.DEFINE_integer('size', 416, 'resize images to')
flags.DEFINE_string('camera', '1', 'camera id')
flags.DEFINE_integer('nframes', 100, 'camera id')
flags.DEFINE_string('output', './output.mp4', 'path to output video')
centroidTracker = CentroidTracker(20)
def main(_argv):
if FLAGS.tiny:
yolo = YoloV3Tiny()
else:
yolo = YoloV3()
yolo.load_weights(FLAGS.weights)
logging.info('weights loaded')
class_names = [c.strip() for c in open(FLAGS.classes).readlines()]
logging.info('classes loaded')
times = []
print("[INFO] loading model...")
prototxt = "models/MobileNetSSD_deploy.prototxt"
model = "models/MobileNetSSD_deploy.caffemodel"
net = cv2.dnn.readNetFromCaffe(prototxt, model)
net.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD)
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
"bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
"dog", "horse", "motorbike", "person", "pottedplant", "sheep",
"sofa", "train", "tvmonitor"]
print("[INFO] starting video stream...")
vs = cv2.VideoCapture(0)
time.sleep(2.0)
ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
trackers = []
trackableObjects = {}
totalFrames = 0
totalDown = 0
totalUp = 0
totalPeople = 0
now = datetime.now().time()
print("now =", now)
hr = now.hour
min = now.minute
def capture_loop(age_net, gender_net):
font = cv2.FONT_HERSHEY_SIMPLEX
# capture frames from the camera
totalFrames = 0
ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
trackers = []
trackableObjects = {}
totalFrames = 0
totalDown = 0
totalUp = 0
W = None
H = None
tracker = dlib.correlation_tracker()
ages = []
genders = []
for frame in camera.capture_continuous(rawCapture,
format="bgr",
use_video_port=True):
# grab the raw NumPy array representing the image, then initialize the timestamp
# and occupied/unoccupied text
image = frame.array
#/usr/local/share/OpenCV/haarcascades/
face_cascade = cv2.CascadeClassifier(
'/usr/local/share/OpenCV/haarcascades/haarcascade_frontalface_alt.xml'
)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
if W is None or H is None:
(H, W) = image.shape[:2]
rects = []
if totalFrames % 5 == 0:
trackers = []
faces = face_cascade.detectMultiScale(gray, 1.1, 5)
print("Found " + str(len(faces)) + " face(s)")
#Draw a rectangle around every found face
ages = []
genders = []
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x + w, y + h), (255, 255, 0), 2)
face_img = image[y:y + h, x:x + w].copy()
blob = cv2.dnn.blobFromImage(face_img,
1, (227, 227),
MODEL_MEAN_VALUES,
swapRB=False)
# Predict gender
gender_net.setInput(blob)
gender_preds = gender_net.forward()
gender = gender_list[gender_preds[0].argmax()]
# Predict age
age_net.setInput(blob)
age_preds = age_net.forward()
age = age_list[age_preds[0].argmax()]
overlay_text = "%s, %s" % (gender, age)
cv2.putText(image, overlay_text, (x, y), font, 1,
(255, 255, 255), 2, cv2.LINE_AA)
tracker = dlib.correlation_tracker()
rect = dlib.rectangle(x, y, x + w, y + h)
tracker.start_track(rgb, rect)
# add the tracker to our list of trackers so we can
# utilize it during skip frames
trackers.append(tracker)
ages.append(age)
genders.append(gender)
else:
# loop over the trackers
for i in range(len(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
trackers[i].update(rgb)
pos = trackers[i].get_position()
# unpack the position object
startX = int(pos.left())
startY = int(pos.top())
endX = int(pos.right())
endY = int(pos.bottom())
cv2.rectangle(image, (startX, startY), (endX, endY),
(255, 255, 0), 2)
overlay_text = "%s, %s" % (genders[i], ages[i])
cv2.putText(image, overlay_text, (startX, startY), font, 1,
(255, 255, 255), 2, cv2.LINE_AA)
# add the bounding box coordinates to the rectangles list
rects.append((startX, startY, endX, endY))
# use the centroid tracker to associate the (1) old object
# centroids with (2) the newly computed object centroids
objects = ct.update(rects, ages, genders, image)
# 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
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
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, (0, 255, 0), 2)
#cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
cv2.imshow("Image", image)
key = cv2.waitKey(1) & 0xFF
# clear the stream in preparation for the next frame
rawCapture.truncate(0)
totalFrames += 1
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
from imutils.video import VideoStream
import numpy as np
import argparse
import imutils
import time
import cv2
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--prototxt", required=True,help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m", "--model", required=True, help="path to Caffe pre-trained model")
ap.add_argument("-c", "--confidence", type=float, default=0.5, help="minimum probability to filter weak detections")
args = vars(ap.parse_args())
# initialize our centroid tracker and frame dimensions
ct = CentroidTracker()
(H, W) = (None, None)
# load our serialized model from disk
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# initialize the video stream and allow the camera sensor to warmup
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
# loop over the frames from the video stream
while True:
# read the next frame from the video stream and resize it
frame = vs.read()
def main_func(args, vs, yolo):
scheduler = BackgroundScheduler() # 初始化任务函数
# 添加调度任务
# 调度方法为 timedTask，触发器选择 interval(间隔性)，间隔时长为 1 秒
scheduler.add_job(timedTask, 'interval',
seconds=cfg.KAFKA.PUSHINTER) # 间隔为1秒
# 启动调度任务
scheduler.start()
writer = None # 写入对象，如果要写入视频，将实例化该对象
W = None
H = None # W,H是我们框架的大小、
ct = CentroidTracker(
maxDisappeared=cfg.CRT.MAXDISAPPEARED,
maxDistance=cfg.CRT.MAXDISTANCE) # 质心追踪对象，连续40帧脱靶则注销#maxt=120
trackers = [] # 用于存储dlib相关追踪器的列表
trackableObjects = {} # 映射id的字典
totalFrames = 0 # 已处理帧总数
global total_up, total_down # 向下运动的人数
fps = FPS().start() # 用于基准测试的每秒帧数估算器
inference_times = []
# 已完成所有初始化，下面遍历传入的帧
while True:
# grab the next frame and handle if we are reading from either
# VideoCapture or VideoStream
st = time.time()
frame = vs.read()
frame = frame[1] if cfg.DATA.INPUT 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 cfg.DATA.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=cfg.FRAME.WIDTH) # 调整框架的最大宽度为500像素，拥有的像素越少，处理速度越快
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
et = time.time()
# if the frame dimensions are empty, set them
if W is None or H is None:
(H, W) = frame.shape[:2]
# 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 = [] # 保存检测到或追踪到的对象
if totalFrames % 2 == 0:
if totalFrames % cfg.FRAME.SKIPFRAMES == 0:
# set the status and initialize our new set of object trackers
status = "Detecting"
trackers_a = [] # 追踪对象的列表
st = time.time()
image = Image.fromarray(frame[..., ::-1]) # bgr to rgb
boxs, class_names = yolo.detect_image(image)
et = time.time()
print('detection take time : ', et - st)
for box in boxs:
box = np.array(box)
(minx, miny, maxx, maxy) = box.astype("int")
cY = int((miny + maxy) / 2.0)
if cY > int(H * cfg.CRT.MINCY) and cY < int(
H * cfg.CRT.MAXCY):
tracker = dlib.correlation_tracker() # 实例化dlib相关性追踪器
rect = dlib.rectangle(
minx, miny, maxx,
maxy) # 将对象的边界框坐标传给dlib.rectangle,结果存储在rect中
cv2.rectangle(frame, (minx, miny), (maxx, maxy),
(2, 255, 0), 2)
rects.append((minx, miny, maxx, maxy))
# 开始追踪
tracker.start_track(rgb, rect)
# add the tracker to our list of trackers so we can
# utilize it during skip frames
trackers_a.append(tracker)
else:
st = time.time()
# loop over the trackers
for tracker in trackers_a:
# 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())
cv2.rectangle(frame, (startX, startY), (endX, endY),
(2, 0, 255), 2)
rects.append((startX, startY, endX, endY))
et = time.time()
tt = et - st
# 画一条水平的可视化线（行人必须交叉才能被追踪），并使用质心跟踪器更新对象质心
# draw a horizontal line in the center of the frame -- once an
# object crosses this line we will determine whether they were
cv2.line(frame, (int(W * 0), int(H * cfg.FRAME.LINE)),
(int(W * 1), int(H * cfg.FRAME.LINE)), (0, 255, 0),
2) # 闸机测试
# 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 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坐标值。
然后，我们通过获取current-object当前质心位置与current-object所有先前质心位置的平均值之间的差来计算方向。
我们之所以这样做是为了确保我们的方向跟踪更加稳定。
如果我们仅存储该人的先前质心位置，则我们可能会错误地计算方向。
"""
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
"""
检查方向是否为负（指示对象正在向上移动）以及质心是否在中心线上方。
在这种情况下，我们增加 totalUp 。
"""
if to.centroids[0][1] < int(
H * cfg.FRAME.LINE) and centroid[1] > int(
H * cfg.FRAME.LINE):
total_down += 1
to.counted = True
to.flag = 'DOWN'
elif to.centroids[0][1] > int(
H * cfg.FRAME.LINE) and centroid[1] < int(
H * cfg.FRAME.LINE):
total_up += 1
to.counted = True
to.flag = 'UP'
# 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)
if to.counted:
cv2.putText(frame, text,
(centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4,
(0, 0, 255), -1)
else:
cv2.putText(frame, text,
(centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4,
(0, 0, 255), -1)
# construct a tuple of information we will be displaying on the
# frame
info = [
("Up", total_up),
("Down", total_down),
("Status", status),
]
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>totalDown", total_down)
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>totalUp", total_up)
# loop over the info tuples and draw them on our frame
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, 255), 2)
if cfg.DATA.OUTPUT is not None and writer is None:
fourcc = cv2.VideoWriter_fourcc(*"MJPG")
writer = cv2.VideoWriter(cfg.DATA.OUTPUT, fourcc, 30, (W, H),
True)
# 写入操作
# check to see if we should write the frame to disk
if writer is not None:
writer.write(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
end_time = time.time()
inference_times.append(end_time - st)
totalFrames += 1
fps.update()
# stop the timer and display FPS information
try:
inference_time = sum(inference_times) / len(inference_times) # 计算FPS
fps1 = 1.0 / inference_time # FPS计算方式
print("---------------------------------------------------------")
print("FPS is ..............{}".format(fps1))
except Exception as e:
print(e)
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
print('totaldown people:', total_down)
print('totalup people:', total_up)
# 写测试信息
with open(info_txt, 'w') as f:
f.write("[INFO] elapsed time: " + str("{:.2f}".format(fps.elapsed())) +
"\n")
f.write("[INFO] approx. FPS: " + str("{:.2f}".format(fps.fps())) +
"\n")
f.write('totaldown people: ' + str(total_down) + "\n")
f.write('totalup people: ' + str(total_up))
# release the video capture
vs.release()
# check to see if we need to release the video writer pointer
if writer is not None:
writer.release()
# close any open windows
cv2.destroyAllWindows()
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("--source", required=True,
help="Source of video stream (webcam/host)")
ap.add_argument("-c", "--confidence", type=float, default=0.2,
help="minimum probability to filter weak detections")
ap.add_argument("-s", "--skip-frames", type=int, default=30,
help="# of skip frames between detections")
ap.add_argument("--ip", required=True,
help="The IP Address")
args = vars(ap.parse_args())
ipaddress = args["ip"]
url = 'http://'+ipaddress+'/html/cam_pic_new.php?'
ct = CentroidTracker() #Makes the magic happen
(H, W) = (None, None) #Sets the size of the image
# initialize the list of class labels MobileNet SSD was trained to
# detect, then generate a set of bounding box colors for each class
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
"bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
"dog", "horse", "motorbike", "person", "pottedplant", "sheep",
"sofa", "train", "tvmonitor"]
#IGNORE all classes except for person
IGNORE = ["background", "aeroplane", "bicycle", "bird", "boat",
"bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
"dog", "horse", "motorbike", "pottedplant", "sheep",
"sofa", "train", "tvmonitor"]
COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))
class MyVideoCapture:
def __init__(self, video_source):
# Open the video source
print("[INFO] loading model...")
self.net = cv2.dnn.readNetFromCaffe(
"mobilenet_ssd/MobileNetSSD_deploy.prototxt",
"mobilenet_ssd/MobileNetSSD_deploy.caffemodel")
print("[INFO] opening video file...")
#"rtsp://*****:*****@192.168.0.200:554/cam/realmonitor?channel=1&subtype=0"
self.vs = cv2.VideoCapture(video_source)
self.W = None
self.H = None
self.ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
self.trackers = []
self.trackableObjects = {}
self.totalFrames = 0
self.totalDown = 0
self.totalUp = 0
self.fps = FPS().start()
if not self.vs.isOpened():
raise ValueError("Unable to open video source", video_source)
def get_frame(self):
if self.vs.isOpened():
ret, frame = self.vs.read()
frame = imutils.resize(frame, width=900)
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
self.H, self.W = frame.shape[:2]
status = "Waiting"
rects = []
if self.totalFrames % 5 == 0:
status = "Detecting"
self.trackers = []
blob = cv2.dnn.blobFromImage(frame, 0.007843, (self.W, self.H),
127.5)
self.net.setInput(blob)
detections = self.net.forward()
for i in np.arange(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
if confidence > 0.4:
idx = int(detections[0, 0, i, 1])
if idx == 15:
box = detections[0, 0, i, 3:7] * np.array(
[self.W, self.H, self.W, self.H])
(startX, startY, endX, endY) = box.astype("int")
cv2.rectangle(frame, (startX, startY),
(endX, endY), (0, 255, 255), 2)
#centroid=(int((startX+endX)/2),int((startY+endY)/2))
#person detection
#if centroid[1]<= self.H-230 and centroid[1]>= self.H-320:
tracker = dlib.correlation_tracker()
rect = dlib.rectangle(startX, startY, endX, endY)
tracker.start_track(rgb, rect)
self.trackers.append(tracker)
else:
for tracker in self.trackers:
status = "Tracking"
tracker.update(rgb)
pos = tracker.get_position()
startX = int(pos.left())
startY = int(pos.top())
endX = int(pos.right())
endY = int(pos.bottom())
rects.append((startX, startY, endX, endY))
#cv2.line(frame, (0, self.H-320), (self.W, self.H-320), (255, 0, 0), 2)
cv2.line(frame, (0, self.H // 2), (self.W, self.H // 2),
(0, 255, 255), 2)
#cv2.line(frame, (0, self.H-230), (self.W, self.H-230), (255, 0, 0), 2)
objects = self.ct.update(rects)
for (objectID, centroid) in objects.items():
to = self.trackableObjects.get(objectID, None)
if to is None:
to = TrackableObject(objectID, centroid)
else:
y = [c[1] for c in to.centroids]
direction = centroid[1] - np.mean(y)
to.centroids.append(centroid)
if not to.counted:
if direction < 0 and centroid[1] < self.H // 2:
self.totalDown += 1
to.counted = True
if direction > 0 and centroid[1] > self.H // 2:
self.totalUp += 1
to.counted = True
self.trackableObjects[objectID] = to
self.totalFrames += 1
info = [
("IN", self.totalUp),
("Status", status),
]
for (i, (k, v)) in enumerate(info):
text = "{}: {}".format(k, v)
#cv2.putText(frame, text, (10, self.H - ((i * 20) + 20)),cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
frame = cv2.resize(frame, (500, 500),
interpolation=cv2.INTER_AREA)
global count
global count1
count1 = self.totalUp
count = self.totalDown
if ret:
# Return a boolean success flag and the current frame converted to BGR
return (ret, cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
else:
return (ret, None)
else:
return (ret, None)
# Release the video source when the object is destroyed
def __del__(self):
if self.vs.isOpened():
self.fps.stop()
self.vs.release()
