# import the necessary packages

import sys

from imutils.video import VideoStream

from imutils.video import FPS

import numpy as np

import argparse

import imutils

import time as t

import cv2

from datetime import datetime, time

import datetime

#import from my python files

from SMS import Send_SMS

from MMS import Send_MMS

from Email import Send_Mail

from DropBox import UploadToDropBox

from AlertTime import is_time_between

import ConfigValues

import FaceDetection

# construct the argument parse and parse the arguments

ap = argparse.ArgumentParser()

ap.add_argument("-v", "--video", default="rtsp://192.168.1.10:7447/5cc263bde4b0b09f7c6923cc_2", help="path to video file or url to RTSP")

ap.add_argument("-n", "--name", default="Front Door", help="camera Name")

ap.add_argument("-rsy", "--ROISY", type=int, default=0, help="ROI Start Y")

ap.add_argument("-rsx", "--ROISX", type=int, default=2, help="ROI Start X")

ap.add_argument("-rey", "--ROIEY", type=int, default=358, help="ROI End Y")

ap.add_argument("-rex", "--ROIEX", type=int, default=638, help="ROI End X")

ap.add_argument("-u", "--use-gpu", type=bool, default=False,help="boolean indicating if CUDA GPU should be used")

ap.add_argument("-ac", "--Alert", type=int, default=5,help="Alert Cool Down Period in minutes")

ap.add_argument("-asph", "--AlertStartPeriodHour", type=int, default=0,help="Alerting Period Start Hour")

ap.add_argument("-aspm", "--AlertStartPeriodMin", type=int, default='00',help="Alerting Period Start Min")

ap.add_argument("-aeph", "--AlertEndPeriodHour", type=int, default=23,help="Alerting Period End Hour")

ap.add_argument("-aepm", "--AlertEndPeriodMin", type=int, default=59,help="Alerting Period End Min")

args = vars(ap.parse_args())

#Path to Temp Save Alert Images

Image_Path = ".\Alert_" + args["name"] + ".jpeg" #Use this line on Windows OS

#Image_Path = "Alert_" + args["name"] + ".jpeg" #Use this line on Linux OS

Image_Name = "Alert_" + args["name"] + ".jpeg"

#Alert Times - Only alert between these times

StartAlerts = time(args["AlertStartPeriodHour"],args["AlertStartPeriodMin"])

EndAlerts = time(args["AlertEndPeriodHour"],args["AlertEndPeriodMin"])

#Detection Models

Prototxt = ConfigValues.ReturnRDODProtoTXT()

Model = ConfigValues.ReturnRTODModel()

SystemConfidence = ConfigValues.ReturnRTODSystemConfidence()

#ROI - Area of the image to monitor for object detections. Pixel Co-ordinates

ROIStartY = args["ROISY"] #80 when the trailer isn't home

ROIStartX = args["ROISX"]

ROIEndY = args["ROIEY"]

ROIEndX = args["ROIEX"]

#Time to Sleep between frames - Limites CPU Time Usage by artifically lowering the frame rate

FrameSleep = ConfigValues.ReturnRTODFrameSleep()

AlertSleepPeriod = args["Alert"] #minutes to sleep after sending an alert to prevent alert flooding

# 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"]

#only display this list of classes on the image windows

ClassesToDisplay =["bicycle", "car", "cat", "dog", "motorbike", "person", "pottedplant", "boat"]

#COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))

StreamLoaded = "False"

while StreamLoaded == "False":

COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))

# load our serialized model from disk

print("[INFO] loading model...")

net = cv2.dnn.readNetFromCaffe(Prototxt, Model)

# check if we are going to use GPU

if args["use_gpu"]:

# set CUDA as the preferable backend and target

print("[INFO] setting preferable backend and target to CUDA...")

net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)

net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)

# initialize the video stream, allow the cammera sensor to warmup,

# and initialize the FPS counter

#print("[INFO] starting video stream..." + args["name"])

print("[INFO] starting video stream..." + args["name"])

try:

RTSP_URL=args["video"]

vs = VideoStream(RTSP_URL).start()

fps = FPS().start()

#Set Date to prevent SMS Flood

#import datetime

SMSAlertDelay = datetime.datetime.now()

FaceDetectionDelay = datetime.datetime.now()

# loop over the frames from the video stream

print("[INFO] attempting video stream loading")

#print("[INFO] starting object detection processing")

while True:

t.sleep(FrameSleep)

# grab the frame from the threaded video stream and resize it

# to have a maximum width of 800 pixels

frame = vs.read()

#frame = imutils.resize(frame, width=800) #defines the size of the picture

#Grab ROI

#[startY:endY, startX:endX]

roi = frame[ROIStartY:ROIEndY, ROIStartX:ROIEndX]

#frame = roi

# grab the frame dimensions and convert it to a blob

(h, w) = roi.shape[:2]

blob = cv2.dnn.blobFromImage(cv2.resize(roi, (300, 300)),0.007843, (300, 300), 127.5)

#blob = cv2.dnn.blobFromImage(roi,1(300, 300), 127.5)

# pass the blob through the network and obtain the detections and

# predictions

net.setInput(blob)

detections = net.forward()

#Draw a box around the area being monitor for Objects

color = (255, 0, 0) # Blue color in BGR

start_point = (ROIStartX, ROIStartY)

end_point = (ROIEndX, ROIEndY)

thickness = 2

frame = cv2.rectangle(frame, start_point, end_point, color, thickness)

y = ROIStartY - 15 if ROIStartY - 15 > 15 else ROIStartY + 15

cv2.putText(frame, "Detection Zone", (ROIStartX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

# 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 > SystemConfidence:

# extract the index of the class label from the

# `detections`, then compute the (x, y)-coordinates of

# the bounding box for the object

idx = int(detections[0, 0, i, 1])

box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])

(startX, startY, endX, endY) = box.astype("int")

# draw the prediction on the frame

label = "{}: {:.2f}%".format(CLASSES[idx],

confidence * 100)

#Only draw the detection clases I am interested in

for o in ClassesToDisplay:

if o in label:

#print(label)

cv2.rectangle(frame, (startX + ROIStartX, startY + ROIStartY), (endX + ROIStartX, endY + ROIStartY),

COLORS[idx], 2)

y = startY + ROIStartY - 15 if startY + ROIStartY - 15 > 15 else startY + ROIStartY + 15

cv2.putText(frame, label, (startX + ROIStartX, y),

cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLORS[idx], 2)

#alert for detection

#print(label)

ValidObjectDetected = 'false'

for vod in ConfigValues.ReturnAlertObjectType():

if(vod in label):

print(label + " Detected")

ValidObjectDetected = 'true'

if(ValidObjectDetected == 'true' and is_time_between(StartAlerts, EndAlerts)):

print(label + " @ " + str(datetime.datetime.now()))

#Test for False Alarm by checking X Lenght of the detection area against the detection

print("")

print("Check for False Detection")

DetectionAreaXLength = args["ROIEX"] - args["ROISX"]

DetectionEventXLength = endX - startX

DectectionPercentage = DetectionEventXLength/DetectionAreaXLength*100

#End Test

if(DectectionPercentage < ConfigValues.ReturnDectectionPercentage()): #The closer to 100% the detection is the more likely it's a false alert.

#Save Image to Disk

cv2.imwrite(Image_Path, frame)

SkipFaceDetection = 'false'

if(SMSAlertDelay < datetime.datetime.now()):

#Send SMS

if(ConfigValues.ReturnTwilioSMSEnabled() == 'true'):

PhoneDestination = ConfigValues.ReturnAlertPhoneDestination()

for PD in PhoneDestination:

Send_SMS(label + " at: " + args["name"], PD)

print("SMS Alerts Sent")

#Send MMS

#Upload image to dropbox and generate a public sharing URL

URL = UploadToDropBox(Image_Name)

print("DropBox Image Public Share URL: " + str(URL))

#Send MMS

if(ConfigValues.ReturnTwilioMMSEnabled() == 'true'):

PhoneDestination = ConfigValues.ReturnAlertPhoneDestination()

for PD in PhoneDestination:

Send_MMS(label + " at: " + args["name"], PD, URL)

print("MMS Alerts Sent")

#Email image of the detection

if(ConfigValues.ReturnMailEnabled() == 'true'):

Send_Mail(Image_Path, args["name"], label)

#Set Alert Delay Period before a new alert can be sent

SMSAlertDelay = datetime.datetime.now() + datetime.timedelta(minutes=AlertSleepPeriod)

loop = 0

print("Alerts Sleeping " + str(AlertSleepPeriod) + " minutes")

SkipFaceDetection = 'true'

else:

SkipFaceDetection = 'false'

#FaceDetection

if(ConfigValues.ReturnFaceDetectionEnabled()=='true' and FaceDetectionDelay < datetime.datetime.now() and SkipFaceDetection=='false'):

print('FaceDetection Enabled')

#[startY:endY, startX:endX]

roiDetected = frame[(startY + ROIStartY):(endY + ROIStartY), (startX + ROIStartX):(endX + ROIStartX)]

cv2.imshow("FaceFrame", roiDetected)

key = cv2.waitKey(1) & 0xFF

#Save Image to Disk

cv2.imwrite(Image_Path, roiDetected)

#Upload image to dropbox and generate a public sharing URL

URL = UploadToDropBox(Image_Name)

print("DropBox Image Public Share URL: " + str(URL))

FaceFound = FaceDetection.FaceDetection(roiDetected)

if(FaceFound=='true'):

FaceDetectionDelay = SMSAlertDelay

else:

print("")

print("False Detection Occured Detection Percentage: " + str(DectectionPercentage))

print("")

else:

if(ValidObjectDetected == 'true'):

#if camera is in cool down period after a detection and the person remains in frame extend the cool down to prevent further alarms

SMSAlertDelay = SMSAlertDelay + datetime.timedelta(seconds=0.5)

print("Object still in frame, Extending Cool Down")

# 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

# update the FPS counter

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()))

#Set StreamLoaded to True after to allow the loop to exit. Loop is only to allow the stream to be restarted if it errors

print("Video Stream & Detection Stopped")

StreamLoaded = "True"

except:

print("")

print("Oops!, ", sys.exc_info()[0])

StreamLoaded = "False"

#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()))

cv2.destroyAllWindows()

vs.stop()

print ("Attempting to re-aquire Stream")

print("")

#t.sleep(5)

#sys.modules[__name__].__dict__.clear()

# do a bit of cleanup

cv2.destroyAllWindows()

#vs.stop()

print(args["name"] + " has exited. This window is safe to close" )