def __init__(self, *args, **kwargs):
""" Initialize the Redis store and framerate monitor. """
super(SocketHandler, self).__init__(*args, **kwargs)
self._store = redis.Redis()
self._pfs = coils.RateTicker((1, 5, 10))
self._prev_image_id = None
def __init__(self, *args, **kwargs):
super(SocketHandler, self).__init__(*args, **kwargs)
# Client to the socket server.
self._map_client = coils.MapSockClient('0.0.0.0', 9002, encode=False)
# Monitor the framerate at 1s, 5s, 10s intervals.
self._fps = coils.RateTicker((1, 5, 10))
def start_recording(url='0'):
# Retrieve command line arguments.
width = None if len(sys.argv) <= 1 else int(sys.argv[1])
height = None if len(sys.argv) <= 2 else int(sys.argv[2])
# width = 480
# height = 360
# Create video capture object, retrying until successful.
if url.isdigit():
cap = open_cap(int(url))
else:
cap = open_cap(url)
print("cap is opened!")
mfps = cap.get(cv2.CAP_PROP_FPS)
# Create client to the Redis store.
store = StrictRedis(host=redishost, port=6379, db=0)
# Set video dimensions, if given.
if width: cap.set(3, width)
if height: cap.set(4, height)
# Monitor the framerate at 1s, 5s, 10s intervals.
fps = coils.RateTicker((1, 5, 10))
# Repeatedly capture current image,
# encode, serialize and push to Redis database.
# Then create unique ID, and push to database as well.
print('Start Recording %s...' % url)
while url in urls:
hello, image = cap.read()
while image is None:
cap.release()
# cap = cv2.VideoCapture(0)
# cap = cv2.VideoCapture('./trimed.mp4')
if url.isdigit():
cap = open_cap(int(url))
else:
cap = open_cap(url)
hello, image = cap.read()
print(None)
time.sleep(0.05)
if image is None:
time.sleep(0.5)
continue
_, image = cv2.imencode('.jpg', image)
value = image.tobytes()
store.set('image' + '_' + url, value)
image_id = os.urandom(4)
store.set('image_id' + '_' + url, image_id)
# Print the framerate.
# text = '{:.2f}, {:.2f}, {:.2f} fps'.format(*fps.tick())
# print(text)
print('Stop Recording %s...' % url)
def writer(self, video_path, idx):
cap = cv2.VideoCapture(video_path)
# Monitor the framerate at 1s, 5s, 10s intervals.
fps = coils.RateTicker((1, 5, 10))
while cap.isOpened():
ret, frame = cap.read()
h, w, c = frame.shape
res_img = frame.reshape(1, w * h * c)
enc_img = base64.b64encode(res_img).decode("utf-8")
self.__store.set(cam_name + idx, enc_img)
self.__store.set(shape_name + idx, pickle.dumps((h, w, c)))
cv2.imshow('VIDEO TO REDIS', frame)
cv2.waitKey(1)
# Print the framerate.
text = '{:.2f}, {:.2f}, {:.2f} fps'.format(*fps.tick())
print(text)
def __init__(self, *args, **kwargs):
super(SocketHandler, self).__init__(*args, **kwargs)
# Client to the socket server.
# self._map_client = coils.MapSockClient(host, port, encode=False)
# Monitor the framerate at 1s, 5s, 10s intervals.
self._fps = coils.RateTicker((1, 5, 10))
self.now = time()
self.speed = 0
self.detector = dlib.get_frontal_face_detector()
self.predictor = dlib.shape_predictor(LANDMARK_FILE)
self.rects = []
self.shape = 0
self.tvec = np.array([160, 120, -300])
self.rvec = np.array([0, 0, 0])
self.cam_w = 320
self.cam_h = 240
self.aT = np.array([2, 2, 1])
self.bT = np.array([-320, -250, 0])
self.aR = np.array([-1.0, 0.75, -1.])
self.bR = np.array([0, 0, 0])
self.poseEstimator = PnpHeadPoseEstimator(self.cam_w, self.cam_h)
self.stream_processor = StreamProcessor(
np.zeros((self.cam_w, self.cam_h)))
self.computing = False
self.rvecInc = 0
self.tvecInc = 0
self.found = None
self.image = ""
self.max_time = 0
def writer(self, video_path, idx):
cap = cv2.VideoCapture(video_path)
# Monitor the framerate at 1s, 5s, 10s intervals.
fps = coils.RateTicker((1, 5, 10))
while cap.isOpened():
ret, frame = cap.read()
h, w, c = frame.shape
# reshape or flatten the frame into a string
res_img = frame.reshape(1, w * h * c)
# base encode string
enc_img = base64.b64encode(res_img).decode("utf-8")
# store the encoded image against corresponding video/camera name - key-value pairs
self.__store.set(cam_name + idx, enc_img)
# store shape of each frame with corresponding camera/video name string
self.__store.set(shape_name + idx, pickle.dumps((h, w, c)))
cv2.imshow('VIDEO TO REDIS', frame)
cv2.waitKey(1)
# Print the framerate.
text = '{:.2f}, {:.2f}, {:.2f} fps'.format(*fps.tick())
print(text)
if cur_sleep < max_sleep:
cur_sleep *= 2
cur_sleep = min(cur_sleep, max_sleep)
continue
cur_sleep = 0.1
# This creates a client to the Redis store, database.
store = redis.Redis(host='<insert IP address>', port=6379) #Insert IP address here
# Set video dimensions, if given.
if width: cap.set(cv2.CAP_PROP_FRAME_WIDTH, width)
if height: cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
# Monitor the framerate at 1s, 5s, 10s intervals.
fps = coils.RateTicker((1, 5, 10))
# Repeatedly capture current image, encode it, convert it to bytes and push
# it to Redis database. Then create unique ID, and push it to database as well.
try:
while True:
retval, frame = cap.read()
if frame is None:
time.sleep(0.5)
continue
retval, frame = cv2.imencode('.jpg', frame) # frame is memory buffer of jpg image
value = np.array(frame).tobytes()
# print(np.array(frame).dtype)
store.set('image', value)
image_id = os.urandom(4)
image,
scaleFactor=1.3,
minNeighbors=3,
minSize=tuple([x / 20 for x in size]),
maxSize=tuple([x / 2 for x in size]),
)
if len(rects):
for a, b, c, d in rects:
result.append((a, b, c, d, self._color))
except:
print('Error in detector !!!')
return result
# Monitor framerates for the given seconds past.
framerate = coils.RateTicker((2, ))
class Postprocessor(mpipe.OrderedWorker):
def doTask(self, (tstamp, rects, )):
"""Augment the input image with results of processing."""
# Make a flat list from a list of lists .
rects = [item for sublist in rects for item in sublist]
# Draw rectangles.
for x1, y1, x2, y2, color in rects:
cv2.rectangle(
images[tstamp],
(x1, y1),
(x1 + x2, y1 + y2),
color=color,
import cv2
import coils
import datetime
import numpy as np
output_tensors = [
'ssd_300_vgg/block4_box/Reshape_1:0', 'ssd_300_vgg/block7_box/Reshape_1:0',
'ssd_300_vgg/block8_box/Reshape_1:0', 'ssd_300_vgg/block9_box/Reshape_1:0',
'ssd_300_vgg/block10_box/Reshape_1:0',
'ssd_300_vgg/block11_box/Reshape_1:0', 'ssd_300_vgg/block4_box/Reshape:0',
'ssd_300_vgg/block7_box/Reshape:0', 'ssd_300_vgg/block8_box/Reshape:0',
'ssd_300_vgg/block9_box/Reshape:0', 'ssd_300_vgg/block10_box/Reshape:0',
'ssd_300_vgg/block11_box/Reshape:0'
]
input_tensor = "Placeholder:0"
fps = coils.RateTicker((60, ))
FPGAinCloudAddress = None
FPGAinCloudssl_enabled = None
FPGAinCloudPort = None
FPGAinCloudaks_servicename = None
CameraURL = None
predictClient = None
scoring = False
PauseBetweenScoreSeconds = 0
async def getInitialTWIN(module_client):
global FPGAinCloudAddress
global FPGAinCloudssl_enabled
global FPGAinCloudPort
def __init__(self):
self.image_acc = None # Maintain accumulation of thresholded differences.
self.tstamp_prev = None # Keep track of previous iteration's timestamp.
self.framerate = coils.RateTicker((1,5,10)) # Monitor framerates.
hello = common[tstamp]
hello['image_diff'] = image_diff
common[tstamp] = hello
# Propagate result to the next stage.
self.putResult(tstamp)
# Accumulate.
hello = cv2.accumulateWeighted(
image,
self.image_acc,
alpha,
)
# Monitor framerates for the given seconds past.
framerate2 = coils.RateTicker((1,5,10))
# Create the output window.
cv2.namedWindow('diff average 4', cv2.cv.CV_WINDOW_NORMAL)
def step2(tstamp):
"""Display the image, stamped with framerate."""
fps_text = '{:.2f}, {:.2f}, {:.2f} fps'.format(*framerate2.tick())
util.writeOSD(common[tstamp]['image_diff'], (fps_text,))
cv2.imshow('diff average 4', common[tstamp]['image_diff'])
cv2.waitKey(1) # Allow HighGUI to process event.
return tstamp
# Assemble the pipeline.
stage1 = mpipe.Stage(Step1)
stage2 = mpipe.FilterStage(
def main(video_uri):
global max_sleep, cur_sleep
while True:
cap = cv2.VideoCapture(
'rtsp://*****:*****@192.168.1.153:554/Streaming/Channels/101?transportmode=unicast&profile=Profile_1'
)
if cap.isOpened():
break
print('not opened, sleeping {}s'.format(cur_sleep))
time.sleep(cur_sleep)
if cur_sleep < max_sleep:
cur_sleep *= 2
cur_sleep = min(cur_sleep, max_sleep)
continue
cur_sleep = 0.1
cap.set(cv2.CAP_PROP_FRAME_COUNT, 3)
# Create client to the Redis store.
store = redis.Redis()
width = None if len(sys.argv) <= 2 else int(sys.argv[2])
height = None if len(sys.argv) <= 3 else int(sys.argv[3])
# Set video dimensions, if given.
if width: cap.set(3, width)
if height: cap.set(4, height)
# Monitor the framerate at 1s, 5s, 10s intervals.
fps = coils.RateTicker((1, 5, 10))
# encode, serialize and push to Redis database.
# Then create unique ID, and push to database as well.
while True:
ticks = time.time()
ret, image = cap.read()
while time.time() - ticks < 3.0:
ret, image = cap.read()
if image is None:
print('image is none')
time.sleep(0.1)
continue
ticks1 = time.time()
small_frame = cv2.resize(image, (0, 0), fx=0.5, fy=0.5)
dets = detector(small_frame, 1)
ticks2 = time.time()
print("detection {} faces takes {} s".format(len(dets),
ticks2 - ticks1))
for i, d in enumerate(dets):
img = image[d.top() * 2:d.bottom() * 2, d.left() * 2:d.right() * 2]
cv2.imwrite(
"{}{}.jpg".format(
'/home/fengping/Pictures/faces/',
time.strftime("%Y%m%d%H%M%S", time.localtime())), img)
img = cv2.resize(img, dim)
img = img.astype(np.float32)
img[:, :, 0] = (img[:, :, 0] - ilsvrc_mean[0])
img[:, :, 1] = (img[:, :, 1] - ilsvrc_mean[1])
img[:, :, 2] = (img[:, :, 2] - ilsvrc_mean[2])
ticks3 = time.time()
# ***************************************************************
# Send the image to the NCS
# ***************************************************************
graph.LoadTensor(img.astype(np.float16), 'user object')
# ***************************************************************
# Get the result from the NCS
# ***************************************************************
output, userobj = graph.GetResult()
print("movidius calssfication cost {}".format(time.time() -
ticks3))
# ***************************************************************
# Print the results of the inference form the NCS
# ***************************************************************
order = output.argsort()[::-1][:6]
print('\n------- predictions --------')
for i in range(0, 6):
print('prediction ' + str(i) + ' (probability ' +
str(output[order[i]]) + ') is ' + labels[order[i]] +
' label index is: ' + str(order[i]))
cv2.rectangle(image, (int(d.left()) * 2, int(d.top()) * 2),
(int(d.right()) * 2, int(d.bottom()) * 2),
(255, 0, 0), 2)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(image, labels[order[0]],
(int(d.left()) * 2 + 6, int(d.top()) * 2 - 6), font,
0.5, (255, 0, 0), 1)
hello, image = cv2.imencode('.jpg', image)
sio = io.BytesIO()
sio.write(image)
value = sio.getvalue()
store.set('image', value)
image_id = os.urandom(4)
store.set('image_id', image_id)
# Print the framerate.
text = '{:.2f}, {:.2f}, {:.2f} fps'.format(*fps.tick())
print(text)
def main(video_uri):
global max_sleep, cur_sleep, avg, lastUploaded
while True:
cap = cv2.VideoCapture(video_uri)
if cap.isOpened():
break
print('not opened, sleeping {}s'.format(cur_sleep))
time.sleep(cur_sleep)
if cur_sleep < max_sleep:
cur_sleep *= 2
cur_sleep = min(cur_sleep, max_sleep)
continue
cur_sleep = 0.1
#cap.set(cv2.CAP_PROP_FRAME_COUNT, 3)
#cap.release()
# Create client to the Redis store.
store = redis.Redis()
# Monitor the framerate at 1s, 5s, 10s intervals.
fps = coils.RateTicker((1, 5, 10))
# encode, serialize and push to Redis database.
# Then create unique ID, and push to database as well.
while True:
text = "Unoccupied"
ticks = time.time()
timestamp = datetime.datetime.now()
ret, image = cap.read()
if image is None:
print('image is none')
time.sleep(0.1)
continue
#cap.release()
ticks1 = time.time()
small_frame = cv2.resize(image, (0, 0), fx=0.5, fy=0.5)
gray = cv2.cvtColor(small_frame, cv2.COLOR_BGR2GRAY)
gray2 = cv2.GaussianBlur(gray, (21, 21), 0)
# if the average frame is None, initialize it
if avg is None:
print("[INFO] starting background model...")
avg = gray2.copy().astype("float")
continue
# accumulate the weighted average between the current frame and
# previous frames, then compute the difference between the current
# frame and running average
cv2.accumulateWeighted(gray2, avg, 0.5)
frameDelta = cv2.absdiff(gray2, cv2.convertScaleAbs(avg))
# threshold the delta image, dilate the thresholded image to fill
# in holes, then find contours on thresholded image
thresh = cv2.threshold(frameDelta, 5, 255, cv2.THRESH_BINARY)[1]
thresh = cv2.dilate(thresh, None, iterations=2)
_, cnts, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# loop over the contours
for c in cnts:
# if the contour is too small, ignore it
if cv2.contourArea(c) < 5000:
continue
# compute the bounding box for the contour, draw it on the frame,
# and update the text
(x, y, w, h) = cv2.boundingRect(c)
cv2.rectangle(image, (x * 2, y * 2), ((x + w) * 2, (y + h) * 2),
(255, 0, 0), 2)
text = "Occupied"
if text == "Occupied":
# check to see if enough time has passed between uploads
if (timestamp - lastUploaded).seconds >= 2.0:
# increment the motion counter
motionCounter += 1
# check to see if the number of frames with consistent motion is
# high enough
if motionCounter >= 5:
lastUploaded = timestamp
motionCounter = 0
#face_locations = opencv_detection(gray)
face_locations = dlib_detection(small_frame)
if len(face_locations) == 0:
print("no face detected at all")
# Draw a rectangle around the faces
for (left, top, right, bottom) in face_locations:
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(image, 'face', (left * 2 + 6, top * 2 - 6),
font, 0.5, (0, 255, 0), 1)
cv2.rectangle(image, (left * 2, top * 2),
(right * 2, bottom * 2), (0, 255, 0), 2)
ticks2 = time.time()
print("detection {} faces takes {} s".format(
len(face_locations), ticks2 - ticks1))
img = image[top * 2:bottom * 2, left * 2:right * 2]
# cv2.imwrite("{}{}.jpg".format('/home/fengping/Pictures/faces/', time.strftime("%Y%m%d%H%M%S", time.localtime())), img)
img = cv2.resize(img, dim)
img = img.astype(np.float32)
img[:, :, 0] = (img[:, :, 0] - ilsvrc_mean[0])
img[:, :, 1] = (img[:, :, 1] - ilsvrc_mean[1])
img[:, :, 2] = (img[:, :, 2] - ilsvrc_mean[2])
ticks3 = time.time()
# ***************************************************************
# Send the image to the NCS
# ***************************************************************
graph.LoadTensor(img.astype(np.float16), 'user object')
# ***************************************************************
# Get the result from the NCS
# ***************************************************************
output, userobj = graph.GetResult()
print("movidius calssfication cost {}".format(
time.time() - ticks3))
# ***************************************************************
# Print the results of the inference form the NCS
# ***************************************************************
order = output.argsort()[::-1][:6]
print('\n------- predictions --------')
for i in range(0, 6):
print('prediction ' + str(i) + ' (probability ' +
str(output[order[i]]) + ') is ' +
labels[order[i]] + ' label index is: ' +
str(order[i]))
cv2.rectangle(image, (left * 2, top * 2),
(right * 2, bottom * 2), (255, 0, 0), 2)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(image, labels[order[0]],
(left * 2 + 6, top * 2 - 6), font, 0.5,
(255, 0, 0), 1)
path = timestamp.strftime("%b-%d_%H_%M_%S" + ".jpg")
cv2.imwrite(path, image)
# otherwise, the room is not occupied
else:
motionCounter = 0
hello, image = cv2.imencode('.jpg', image)
sio = io.BytesIO()
sio.write(image)
value = sio.getvalue()
store.set('image', value)
image_id = os.urandom(4)
store.set('image_id', image_id)
# Print the framerate.
#text = '{:.2f}, {:.2f}, {:.2f} fps'.format(*fps.tick())
#print(text)
cap.relsese()
