def test_multiserver_mode():
"""
Testing NetGear's Multi-Server Mode with three unique servers
"""
try:
#open network stream
stream = VideoGear(source=return_testvideo_path()).start()
#define and activate Multi-Server Mode
options = {'multiserver_mode': True}
#define a single client
client = NetGear(port = ['5556', '5557', '5558'], pattern = 1, receive_mode = True, logging = True, **options)
#define client-end dict to save frames inaccordance with unique port
client_frame_dict = {}
#define three unique server
server_1 = NetGear(pattern = 1, port = '5556', logging = True, **options) #at port `5556`
server_2 = NetGear(pattern = 1, port = '5557', logging = True, **options) #at port `5557`
server_3 = NetGear(pattern = 1, port = '5558', logging = True, **options) #at port `5558`
#generate a random input frame
frame_server = None
i = 0
while (i < random.randint(10, 100)):
frame_server = stream.read()
i+=1
#check if input frame is valid
assert not(frame_server is None)
#send frame from Server-1 to client and save it in dict
server_1.send(frame_server)
unique_address, frame = client.recv()
client_frame_dict[unique_address] = frame
#send frame from Server-2 to client and save it in dict
server_2.send(frame_server)
unique_address, frame = client.recv()
client_frame_dict[unique_address] = frame
#send frame from Server-3 to client and save it in dict
server_3.send(frame_server)
unique_address, frame = client.recv()
client_frame_dict[unique_address] = frame
#clean all resources
stream.stop()
server_1.close()
server_2.close()
server_3.close()
client.close()
#check if recieved frames from each unique server exactly matches input frame
for key in client_frame_dict.keys():
assert np.array_equal(frame_server, client_frame_dict[key])
except Exception as e:
if isinstance(e, (ZMQError, ValueError)):
logger.error(traceback.print_tb(e.__traceback__))
else:
pytest.fail(str(e))
def test_bidirectional_mode(pattern, target_data, options):
"""
Testing NetGear's Bidirectional Mode with different data-types
"""
# initialize
stream = None
server = None
client = None
try:
logger.debug("Given Input Data: {}".format(target_data))
# open stream
stream = VideoGear(source=return_testvideo_path()).start()
# define params
client = NetGear(pattern=pattern, receive_mode=True, **options)
server = NetGear(pattern=pattern, **options)
# get frame from stream
frame_server = stream.read()
assert not (frame_server is None)
# check if target data is numpy ndarray
if isinstance(target_data, np.ndarray):
# sent frame and data from server to client
server.send(target_data, message=target_data)
# client receives the data and frame and send its data
server_data, frame_client = client.recv(return_data=target_data)
# server receives the data and cycle continues
client_data = server.send(target_data, message=target_data)
# logger.debug data received at client-end and server-end
logger.debug("Data received at Server-end: {}".format(frame_client))
logger.debug("Data received at Client-end: {}".format(client_data))
assert np.array_equal(client_data, frame_client)
else:
# sent frame and data from server to client
server.send(frame_server, message=target_data)
# client receives the data and frame and send its data
server_data, frame_client = client.recv(return_data=target_data)
# server receives the data and cycle continues
client_data = server.send(frame_server, message=target_data)
# check if received frame exactly matches input frame
assert np.array_equal(frame_server, frame_client)
# logger.debug data received at client-end and server-end
logger.debug("Data received at Server-end: {}".format(server_data))
logger.debug("Data received at Client-end: {}".format(client_data))
assert client_data == server_data
except Exception as e:
if isinstance(e, (ZMQError, ValueError)):
logger.exception(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.stop()
if not (server is None):
server.close()
if not (client is None):
client.close()
def test_playback(address, port):
"""
Tests NetGear Bare-minimum network playback capabilities
"""
stream = None
server = None
client = None
try:
# open stream
stream = VideoGear(source=return_testvideo_path()).start()
# open server and client with default params
client = NetGear(address=address, port=port, receive_mode=True)
server = NetGear(address=address, port=port)
# playback
while True:
frame_server = stream.read()
if frame_server is None:
break
server.send(frame_server) # send
frame_client = client.recv() # recv
except Exception as e:
if isinstance(e, (ZMQError, ValueError)) or address == "www.idk.com":
logger.exception(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.stop()
if not (server is None):
server.close()
if not (client is None):
client.close()
def test_patterns(pattern):
"""
Testing NetGear different messaging patterns
"""
#open stream
try:
stream = VideoGear(source=return_testvideo_path()).start()
#define parameters
options = {'flag' : 0, 'copy' : True, 'track' : False}
client = NetGear(pattern = pattern, receive_mode = True, logging = True, **options)
server = NetGear(pattern = pattern, logging = True, **options)
#initialize
frame_server = None
#select random input frame from stream
i = 0
while (i < random.randint(10, 100)):
frame_server = stream.read()
i+=1
#check if input frame is valid
assert not(frame_server is None)
#send frame over network
server.send(frame_server)
frame_client = client.recv()
#clean resources
stream.stop()
server.close()
client.close()
#check if recieved frame exactly matches input frame
assert np.array_equal(frame_server, frame_client)
except Exception as e:
if isinstance(e, (ZMQError, ValueError)):
logger.error(traceback.print_tb(e.__traceback__))
else:
pytest.fail(str(e))
def test_playback(): """ Tests NetGear Bare-minimum network playback capabilities """ try: #open stream stream = VideoGear(source=return_testvideo_path()).start() #open server and client with default params client = NetGear(receive_mode = True) server = NetGear() #playback while True: frame_server = stream.read() if frame_server is None: break server.send(frame_server) #send frame_client = client.recv() #recv #clean resources stream.stop() server.close() client.close() except Exception as e: if isinstance(e, (ZMQError, ValueError)): logger.debug(traceback.print_tb(e.__traceback__)) else: pytest.fail(str(e))
def test_playback(address, port):
"""
Tests NetGear Bare-minimum network playback capabilities
"""
stream = None
server = None
client = None
try:
# open stream
stream = cv2.VideoCapture(return_testvideo_path())
# open server and client with default params
client = NetGear(address=address, port=port, receive_mode=True)
server = NetGear(address=address, port=port)
# playback
while True:
(grabbed, frame_server) = stream.read()
if not grabbed:
break
server.send(frame_server) # send
frame_client = client.recv() # recv
except Exception as e:
if (isinstance(e, (ZMQError, ValueError, RuntimeError))
or address == "172.31.11.15.77"):
logger.exception(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.release()
if not (server is None):
server.close()
if not (client is None):
client.close()
def test_client_reliablity(options):
"""
Testing validation function of NetGear API
"""
client = None
frame_client = None
try:
# define params
client = NetGear(
pattern=1,
port=[5587] if "multiserver_mode" in options.keys() else 6657,
receive_mode=True,
logging=True,
**options)
# get data without any connection
frame_client = client.recv()
# check for frame
if frame_client is None:
raise RuntimeError
except Exception as e:
if isinstance(e, (RuntimeError)):
pytest.xfail("Reconnection ran successfully.")
else:
logger.exception(str(e))
finally:
# clean resources
if not (client is None):
client.close()
def test_compression():
"""
Testing NetGear's real-time frame compression capabilities
"""
try:
#open streams
stream = VideoGear(source=return_testvideo_path()).start()
#define client parameters
options = {'compression_param':cv2.IMREAD_COLOR} #read color image
client = NetGear(pattern = 1, receive_mode = True, logging = True, **options)
#define server parameters
options = {'compression_format': '.jpg', 'compression_param':[cv2.IMWRITE_JPEG_OPTIMIZE, 20]} #JPEG compression
server = NetGear(pattern = 1, logging = True, **options)
#send over network
while True:
frame_server = stream.read()
if frame_server is None: break
server.send(frame_server)
frame_client = client.recv()
#clean resources
stream.stop()
server.close()
client.close()
except Exception as e:
if isinstance(e, (ZMQError, ValueError)):
logger.error(traceback.print_tb(e.__traceback__))
else:
pytest.fail(str(e))
def test_primary_mode(receive_mode):
"""
Tests NetGear Bare-minimum network playback capabilities
"""
stream = None
conn = None
try:
# open stream
options_gear = {"THREAD_TIMEOUT": 60}
stream = VideoGear(source=return_testvideo_path(),
**options_gear).start()
frame = stream.read()
# open server and client with default params
conn = NetGear(receive_mode=receive_mode)
if receive_mode:
conn.send(frame)
else:
frame_client = conn.recv()
except Exception as e:
if isinstance(e, ValueError):
pytest.xfail("Test Passed!")
elif isinstance(e, (queue.Empty)):
logger.exception(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.stop()
if not (conn is None):
conn.close()
class CamStreamer(object):
def __init__(self):
self.client = NetGear(address="192.168.0.10",
port="5566",
protocol='tcp',
pattern=1,
logging=True,
receive_mode=True,
**options)
def __del__(self):
self.client.close()
def get_frame(self):
frame = None
try:
image = self.client.recv()
# 因为opencv读取的图片并非jpeg格式，因此要用motion JPEG模式需要先将图片转码成jpg格式图片
ret, jpeg = cv2.imencode('.jpg', image)
frame = jpeg.tobytes()
#print frame
except:
#print "frame process error!"
if camstream:
cam = camstream.pop()
del cam
return frame
async def test_benchmark_NetGear():
"""
Benchmark NetGear original in FPS
"""
try:
# open stream with valid source
stream = VideoGear(source=return_testvideo_path()).start()
# open server and client
client = NetGear(receive_mode=True, pattern=1)
server = NetGear(pattern=1)
# start FPS handler
fps = FPS().start()
# playback
while True:
frame_server = stream.read()
if frame_server is None:
break
fps.update() # update
server.send(frame_server) # send
frame_client = client.recv() # recv
stream.stop()
except Exception as e:
pytest.fail(str(e))
finally:
# close
server.close()
client.close()
logger.info("NetGear approx. FPS: {:.2f}".format(fps.average_fps()))
def test_secure_mode(pattern, security_mech, custom_cert_location, overwrite_cert):
"""
Testing NetGear's Secure Mode
"""
# define security mechanism
options = {
"secure_mode": security_mech,
"custom_cert_location": custom_cert_location,
"overwrite_cert": overwrite_cert,
}
# initialize
frame_server = None
stream = None
server = None
client = None
try:
# open stream
stream = VideoGear(source=return_testvideo_path()).start()
# define params
server = NetGear(pattern=pattern, logging=True, **options)
client = NetGear(pattern=pattern, receive_mode=True, logging=True, **options)
# select random input frame from stream
i = 0
while i < random.randint(10, 100):
frame_server = stream.read()
i += 1
# check input frame is valid
assert not (frame_server is None)
# send and recv input frame
server.send(frame_server)
frame_client = client.recv()
# check if received frame exactly matches input frame
assert np.array_equal(frame_server, frame_client)
except Exception as e:
if isinstance(e, (ZMQError, ValueError)):
logger.exception(str(e))
elif (
isinstance(e, AssertionError)
and custom_cert_location == "INVALID_DIRECTORY"
):
logger.exception(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.stop()
if not (server is None):
server.close()
if not (client is None):
client.close()
def test_patterns(pattern):
"""
Testing NetGear different messaging patterns
"""
# define parameters
options = {
"flag": 0,
"copy": False,
"track": False,
"jpeg_compression": False
}
# initialize
frame_server = None
stream = None
server = None
client = None
try:
# open stream
stream = cv2.VideoCapture(return_testvideo_path())
client = NetGear(pattern=pattern,
receive_mode=True,
logging=True,
**options)
server = NetGear(pattern=pattern, logging=True, **options)
# select random input frame from stream
i = 0
random_cutoff = random.randint(10, 100)
while i < random_cutoff:
(grabbed, frame_server) = stream.read()
i += 1
# check if input frame is valid
assert not (frame_server is None)
# send frame over network
server.send(frame_server)
frame_client = client.recv(
return_data=[1, 2, 3] if pattern == 2 else None)
# check if received frame exactly matches input frame
assert np.array_equal(frame_server, frame_client)
except Exception as e:
if isinstance(e, (ZMQError, ValueError, RuntimeError)):
logger.exception(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.release()
if not (server is None):
server.close()
if not (client is None):
client.close()
def test_compression(options_server):
"""
Testing NetGear's real-time frame compression capabilities
"""
# initialize
stream = None
server = None
client = None
try:
# open streams
options_gear = {"THREAD_TIMEOUT": 60}
colorspace = (
"COLOR_BGR2GRAY"
if isinstance(options_server["jpeg_compression"], str)
and options_server["jpeg_compression"].strip().upper() == "GRAY"
else None
)
stream = VideoGear(
source=return_testvideo_path(), colorspace=colorspace, **options_gear
).start()
client = NetGear(pattern=0, receive_mode=True, logging=True)
server = NetGear(pattern=0, logging=True, **options_server)
# send over network
while True:
frame_server = stream.read()
if frame_server is None:
break
server.send(frame_server)
frame_client = client.recv()
if (
isinstance(options_server["jpeg_compression"], str)
and options_server["jpeg_compression"].strip().upper() == "GRAY"
):
assert (
frame_server.ndim == frame_client.ndim
), "Grayscale frame Test Failed!"
except Exception as e:
if isinstance(e, (ZMQError, ValueError, RuntimeError, queue.Empty)):
logger.exception(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.stop()
if not (server is None):
server.close()
if not (client is None):
client.close()
class VideoCamera(object):
def __init__(self):
self.BC = BirdCamera()
options = {'flag' : 0, 'copy' : False, 'track' : False, 'compression_param':cv2.IMREAD_COLOR}
self.client = NetGear(address = '192.168.2.71', port = '5555', protocol = 'tcp', pattern = 0, receive_mode = True, logging = True, **options)
self.grabbed = True
self.frame = self.client.recv()
self.lock = threading.Lock()
threading.Thread(target=self.update, args=()).start()
def __del__(self):
self.client.close()
def get_frame(self):
with self.lock:
if self.frame is not None:
image = self.frame
ret, jpeg = cv2.imencode('.jpg', image)
return jpeg.tobytes()
else:
return None
def update(self):
while True:
with self.lock:
frame = self.client.recv()
self.BC.processimages(frame)
# for location in self.BC.objectscurrentframe:
# cv2.rectangle(frame , ( int(location[0] - vert / 4), int(location[1] - vert / 4)), (int(location[0] + vert / 4), int(location[1] + vert / 4)), (255, 255, 255))
concat_frame = np.concatenate((self.BC.fgmask,self.BC.imdil, self.BC._reduceframe(frame)),axis=0)
self.frame = concat_frame
if self.frame is not None:
self.grabbed = True
else:
self.grabbed = False
def test_compression(options_client):
"""
Testing NetGear's real-time frame compression capabilities
"""
options = {
"compression_format":
".jpg",
"compression_param": [
cv2.IMWRITE_JPEG_QUALITY,
20,
cv2.IMWRITE_JPEG_OPTIMIZE,
True,
],
} # JPEG compression
# initialize
stream = None
server = None
client = None
try:
# open streams
options_gear = {"THREAD_TIMEOUT": 60}
stream = VideoGear(source=return_testvideo_path(),
**options_gear).start()
client = NetGear(pattern=0,
receive_mode=True,
logging=True,
**options_client)
server = NetGear(pattern=0, logging=True, **options)
# send over network
while True:
frame_server = stream.read()
if frame_server is None:
break
server.send(frame_server)
frame_client = client.recv()
except Exception as e:
if isinstance(e, (ZMQError, ValueError, RuntimeError, queue.Empty)):
logger.exception(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.stop()
if not (server is None):
server.close()
if not (client is None):
client.close()
def test_bidirectional_mode(target_data):
"""
Testing NetGear's Bidirectional Mode with different datatypes
"""
try:
logger.debug('Given Input Data: {}'.format(target_data))
#open strem
stream = VideoGear(source=return_testvideo_path()).start()
#activate bidirectional_mode
options = {'bidirectional_mode': True}
#define params
client = NetGear(receive_mode = True, logging = True, **options)
server = NetGear(logging = True, **options)
#get frame from stream
frame_server = stream.read()
assert not(frame_server is None)
#sent frame and data from server to client
server.send(frame_server, message = target_data)
#client recieves the data and frame and send its data
server_data, frame_client = client.recv(return_data = target_data)
#server recieves the data and cycle continues
client_data = server.send(frame_server, message = target_data)
#clean resources
stream.stop()
server.close()
client.close()
#logger.debug data recieved at client-end and server-end
logger.debug('Data recieved at Server-end: {}'.format(server_data))
logger.debug('Data recieved at Client-end: {}'.format(client_data))
#check if recieved frame exactly matches input frame
assert np.array_equal(frame_server, frame_client)
#check if client-end data exactly matches server-end data
assert client_data == server_data
except Exception as e:
if isinstance(e, (ZMQError, ValueError)):
logger.error(traceback.print_tb(e.__traceback__))
else:
pytest.fail(str(e))
class Compute:
def __init__(self, **kwargs):
self.compute = NetGear(**kwargs)
def read(self, processed_frame=None):
"""Read data from client and send back a processed frame
Args:
processed_frame (NumPy array)
Returns:
data : server_data, frame (string, NumPy array).
Note : server_data can be any type, but here it will be
only a string
"""
data = self.compute.recv(return_data=processed_frame)
return data
def close(self):
"""Safely terminates the threads, and NetGear resources."""
self.compute.close()
def test_compression(options_client):
"""
Testing NetGear's real-time frame compression capabilities
"""
try:
# open streams
stream = VideoGear(source=return_testvideo_path()).start()
client = NetGear(pattern=0,
receive_mode=True,
logging=True,
**options_client)
# define server parameters
options = {
"compression_format":
".jpg",
"compression_param": [
cv2.IMWRITE_JPEG_QUALITY,
20,
cv2.IMWRITE_JPEG_OPTIMIZE,
True,
],
} # JPEG compression
server = NetGear(pattern=0, logging=True, **options)
# send over network
while True:
frame_server = stream.read()
if frame_server is None:
break
server.send(frame_server)
frame_client = client.recv()
# clean resources
stream.stop()
server.close()
client.close()
except Exception as e:
if isinstance(e, (ZMQError, ValueError)):
logger.exception(str(e))
else:
pytest.fail(str(e))
class server:
def __init__(self, ip='192.168.10.50', port_1=10000, port_2=5454):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server_address = (ip, port_1)
self.sock.bind(self.server_address)
self.client = NetGear(address=ip,
port=port_2,
protocol='tcp',
pattern=0,
receive_mode=True,
logging=True,
flag=0,
copy=False,
track=False)
def receive_data(self, image_capture=True):
if image_capture:
frame = self.client.recv()
data, address = self.sock.recvfrom(100) # blocking IO
data = json.loads(data)
return frame, data, address
def test_secure_mode(pattern, security_mech, custom_cert_location, overwrite_cert):
"""
Testing NetGear's Secure Mode
"""
try:
#open stream
stream = VideoGear(source=return_testvideo_path()).start()
#define security mechanism
options = {'secure_mode': security_mech, 'custom_cert_location': custom_cert_location, 'overwrite_cert': overwrite_cert}
#define params
server = NetGear(pattern = pattern, logging = True, **options)
client = NetGear(pattern = pattern, receive_mode = True, logging = True, **options)
#initialize
frame_server = None
#select random input frame from stream
i = 0
while (i < random.randint(10, 100)):
frame_server = stream.read()
i+=1
#check input frame is valid
assert not(frame_server is None)
#send and recv input frame
server.send(frame_server)
frame_client = client.recv()
#clean resources
stream.stop()
server.close()
client.close()
#check if recieved frame exactly matches input frame
assert np.array_equal(frame_server, frame_client)
except Exception as e:
if isinstance(e, (ZMQError, ValueError)):
logger.error(traceback.print_tb(e.__traceback__))
else:
pytest.fail(str(e))
# loop over
while True:
# read frames from stream
frame = stream.read()
# check for frame if Nonetype
if frame is None:
break
# reducer frames size if you want more performance, otherwise comment this line
frame = reducer(frame, percentage = 30) #reduce frame by 30%
# receive data from server and also send our data
data = client.recv(return_data = frame)
# check for data if None
if data is None:
break
# extract server_data & frame from data
server_data, frame = data
# again check for frame if None
if frame is None:
break
# {do something with the extracted frame and data here}
# lets print extracted server data
import socket
import cv2
import numpy as np
from vidgear.gears import NetGear
#define netgear client with `receive_mode = True` and default settings
server = NetGear(address='127.0.0.1', port='35560', receive_mode=True)
# infinite loop
while True:
frame = server.recv()
if frame is None:
break
cv2.namedWindow('Output Frame', cv2.WINDOW_GUI_NORMAL)
cv2.setWindowProperty('Output Frame', cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN)
cv2.moveWindow('Output Frame', 100, 400)
cv2.resizeWindow('Output Frame', 400, 255)
cv2.imshow("Output Frame", frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
# close output window
cv2.destroyAllWindows()
# safely close client
server.close()
# Define NetGear Client at Server's IP address and assign a unique port address and other parameters
client = NetGear(
address=addr,
port=port,
protocol=proto,
pattern=pattern,
receive_mode=True,
logging=True,
**
options) # !!! change following IP address '192.168.x.xxx' with yours !!!
# loop over
while True:
# receive data from server
frame = client.recv()
# check for frame if None
if frame is None:
break
# {do something with frame here}
# Show output window
cv2.imshow("Client 5577 Output", frame)
# check for 'q' key if pressed
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
def main(args):
client_options = {
'compression_format': '.jpg',
'compression_param': cv2.IMREAD_COLOR,
'flag': 1
}
client = NetGear(address=args.address,
port=args.port,
protocol='tcp',
bidirectional_mode=True,
pattern=1,
receive_mode=True,
logging=True,
**client_options)
face_detector = None
mask_detector = None
if args.detection_method == 'dnn':
model_file = "models/res10_300x300_ssd_iter_140000_fp16.caffemodel"
config_file = "models/deploy.prototxt"
face_detector = utils.load_cvdnn(model_file, config_file)
elif args.detection_method == 'haar':
model_file = 'models/haarcascade_frontalface_alt.xml'
face_detector = utils.load_haar_cascade(model_file)
if not args.ignore_masks:
# Load mask detector
# Credit for the model: https://github.com/chandrikadeb7/Face-Mask-Detection
mask_detector = utils.load_masknet("models/mask_detector.model")
# Keep track of FPS
frame_counter = 0
start_time = None
# Bookkeeping for face tracking
next_id = count(0)
objects = {}
target_coords = []
target_bb_size = 0
target = None
while True:
# receive frames from network
data = client.recv(return_data=(target_coords, target_bb_size))
if start_time is None:
start_time = time.time()
# check for received frame if Nonetype
if data is None:
break
_, frame = data
if frame_counter % args.frameskip == 0:
if args.detection_method == 'dnn':
face_locations = utils.get_face_locations_dnn(
frame, face_detector)
else:
face_locations = utils.get_face_locations_hog(frame)
# Update the object positions and other parametes
utils.update_objects(objects, face_locations, next_id)
if frame_counter % args.mask_detect_freq == 0:
# Update the mask status of the faces
utils.detect_mask(frame, objects, mask_detector)
# Choose the target
if target not in objects.keys() or objects[target]['has_mask']:
temp = [i for i, val in objects.items() if not val['has_mask']]
if temp:
target = temp[0]
else:
target = None
if target is not None:
target_coords = objects[target]['centroid']
# Change to centered coordinates
h, w, _ = frame.shape
x0, y0 = (w // 2, h // 2)
target_coords = (target_coords[0] - x0, target_coords[1] - y0)
# Bounding box size
(top, right, bottom, left) = objects[target]['bounding_box']
target_bb_size = round(
np.linalg.norm([(top, right), (bottom, left)]), 2)
else:
target_coords = []
target_bb_size = 0
if args.show_video:
# Draw the extra information onto the frame
frame = utils.draw_bounding_boxes(frame, objects)
# h, w, _ = frame.shape
# cv2.circle(frame, (w//2, h//2), radius=5,
# color=(0, 255, 0), thickness=-1)
# Show output
if args.track_face and target is not None:
(top, right, bottom, left) = objects[target]['bounding_box']
cv2.imshow("Output Frame", frame[bottom:top, left:right])
else:
cv2.imshow("Output Frame", frame)
# check for 'q' key if pressed
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
frame_counter += 1
elapsed_time = time.time() - start_time
print(f"avg FPS: {frame_counter/elapsed_time}")
# close output window
cv2.destroyAllWindows()
# safely close client
client.close()
def receive(category_index,
model,
address,
port,
protocol,
pattern=0,
min_detections=10,
min_confidence=0.7,
server_plugins={},
**kwargs):
"""Main receiver loop for network detection
Args:
category_index (category_index): category_index
model (model): Model to use
address (str): URL of `OpenCV` sender / Pi
port (int): Port of `OpenCV` sender / Pi
protocol (str): Protocol of of `OpenCV` sender / Pi
pattern (int, optional): ZMQ Pattern. 0=`zmq.PAIR`, 1=`zmq.REQ/zmq.REP`; 2=`zmq.PUB,zmq.SUB`. Defaults to 0.
min_detections (int, optional): Minimum detections required to yield a positive result. Defaults to 10.
min_confidence (float, optional): Minimum average confidence required to yield a positive result. Defaults to 0.7.
Yields:
bool: True for a successful detection
"""
client = NetGear(
address=address,
port=str(port),
protocol=protocol,
pattern=pattern,
receive_mode=True,
logging=True) # Define netgear client at Server IP address.
# For detection thresholds
c = 0
if 'detection_threshold' in kwargs and 'fps' in kwargs:
THRESHOLD_FRAMES = kwargs.get('detection_threshold') * kwargs.get(
'fps')
logger.debug('Using {} frames as {}s threshold'.format(
THRESHOLD_FRAMES, kwargs.get('detection_threshold')))
else:
THRESHOLD_FRAMES = -1
logger.warning('Threshold is disabled')
# Detection
i = 0
confidence = 0
p_res = False
# infinite loop
while True:
# receive frames from network
# TODO: time sleep comes from my fork of vidgear - might break lib
frame = client.recv()
logger.debug('Image received')
image_np = np.copy(frame)
# check if frame is None
if image_np is None:
logger.error('No frame available')
break
c += 1
# If threshold is enabled, drop frames if we got a previous result and are below the detection threshold
if THRESHOLD_FRAMES != -1 and c < THRESHOLD_FRAMES and p_res:
logger.debug('Below threshold, dropping frame at {}'.format(c))
continue
# Server plugins - before
run_image_detector_plugins_before(server_plugins, image_np)
# Actual detection.
res, i, confidence, np_det_img = detect(model, category_index,
image_np, i, confidence,
min_detections, min_confidence)
if res:
yield True
p_res = res
# Server plugins - after
run_image_detector_plugins_after(server_plugins, res, i, confidence,
np_det_img)
key = cv2.waitKey(1) & 0xFF
# check for 'q' key-press
if key == ord("q"):
# if 'q' key-pressed break out
break
# close output window
cv2.destroyAllWindows()
# safely close client
client.close()
influxdb_client.write_points(
influx_data,
database="MainDatabase",
batch_size=batch_size,
time_precision="u", # micro secs
protocol="line",
)
influx_data = []
# add random delay
if np.random.random() < args.delay_prob:
random_delay = round(np.random.random() / 10, 2)
time.sleep(random_delay)
else:
random_delay = 0
# receive frames from network
data = client.recv()
if data is None:
break
toc = time.time()
n_bytes_2 = data_rate.get_rx_bytes()
# Current FPS
fps = 1 / (toc - tic)
# Current Data Rate
rx_rate = round((n_bytes_2 - n_bytes_1) / ((toc - tic) * 1024.0 * 1024.0),
4)
# reset clock
tic = toc
# receive frame and timestamp
def test_bidirectional_mode(pattern, target_data, options):
"""
Testing NetGear's Bidirectional Mode with different data-types
"""
# initialize
stream = None
server = None
client = None
try:
logger.debug(
"Given Input Data: {}".format(target_data if not isinstance(
target_data, np.ndarray) else "IMAGE"))
# open stream
options_gear = {"THREAD_TIMEOUT": 60}
# change colorspace
colorspace = ("COLOR_BGR2GRAY"
if isinstance(options["jpeg_compression"], str)
and options["jpeg_compression"].strip().upper() == "GRAY"
else None)
if colorspace == "COLOR_BGR2GRAY" and isinstance(
target_data, np.ndarray):
target_data = cv2.cvtColor(target_data, cv2.COLOR_BGR2GRAY)
stream = VideoGear(source=return_testvideo_path(),
colorspace=colorspace,
**options_gear).start()
# define params
client = NetGear(pattern=pattern,
receive_mode=True,
logging=True,
**options)
server = NetGear(pattern=pattern, logging=True, **options)
# check if target data is numpy ndarray
if isinstance(target_data, np.ndarray):
# sent frame and data from server to client
server.send(target_data, message=target_data)
# client receives the data and frame and send its data
server_data, frame_client = client.recv(return_data=target_data)
# server receives the data and cycle continues
client_data = server.send(target_data)
# test if recieved successfully
assert not (client_data is None), "Test Failed!"
else:
# get frame from stream
frame_server = stream.read()
assert not (frame_server is None)
# sent frame and data from server to client
server.send(frame_server, message=target_data)
# client receives the data and frame and send its data
server_data, frame_client = client.recv(return_data=target_data)
# server receives the data and cycle continues
client_data = server.send(frame_server, message=target_data)
# check if received frame exactly matches input frame
if not options["jpeg_compression"] in [True, "GRAY", ["invalid"]]:
assert np.array_equal(frame_server, frame_client)
# logger.debug data received at client-end and server-end
logger.debug("Data received at Server-end: {}".format(server_data))
logger.debug("Data received at Client-end: {}".format(client_data))
assert client_data == server_data
except Exception as e:
if isinstance(e, (ZMQError, ValueError, RuntimeError, queue.Empty)):
pytest.xfail(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.stop()
if not (server is None):
server.close()
if not (client is None):
client.close()
def test_multiserver_mode(pattern, options):
"""
Testing NetGear's Multi-Server Mode with three unique servers
"""
# initialize
frame_server = None
stream = None
server_1 = None
server_2 = None
server_3 = None
client = None
# define client-end dict to save frames in-accordance with unique port
client_frame_dict = {}
try:
# open stream
stream = cv2.VideoCapture(return_testvideo_path())
# define a single client
client = NetGear(port=["5556", "5557", "5558"],
pattern=pattern,
receive_mode=True,
logging=True,
**options)
# define three unique server
server_1 = NetGear(pattern=pattern,
port="5556",
logging=True,
**options) # at port `5556`
server_2 = NetGear(pattern=pattern,
port="5557",
logging=True,
**options) # at port `5557`
server_3 = NetGear(pattern=pattern,
port="5558",
logging=True,
**options) # at port `5558`
i = 0
while i < random.randint(10, 100):
(grabbed, frame_server) = stream.read()
i += 1
# check if input frame is valid
assert not (frame_server is None)
# send frame from Server-1 to client and save it in dict
server_1.send(frame_server)
unique_address, frame = client.recv()
client_frame_dict[unique_address] = frame
# send frame from Server-2 to client and save it in dict
server_2.send(frame_server)
unique_address, frame = client.recv()
client_frame_dict[unique_address] = frame
# send frame from Server-3 to client and save it in dict
server_3.send(frame_server)
unique_address, frame = client.recv()
client_frame_dict[unique_address] = frame
# check if recieved frames from each unique server exactly matches input frame
for key in client_frame_dict.keys():
assert np.array_equal(frame_server, client_frame_dict[key])
except Exception as e:
if isinstance(e, (ZMQError, ValueError, RuntimeError)):
pytest.xfail(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.release()
if not (server_1 is None):
server_1.close()
if not (server_2 is None):
server_2.close()
if not (server_3 is None):
server_3.close()
if not (client is None):
client.close()
def test_multiclient_mode(pattern):
"""
Testing NetGear's Multi-Client Mode with three unique clients
"""
# define and activate Multi-Client Mode
options = {
"multiclient_mode": True,
"bidirectional_mode": True,
"jpeg_compression": False,
} # bidirectional_mode is activated for testing only
# initialize
frame_client = None
stream = None
server = None
client_1 = None
client_2 = None
client_3 = None
try:
# open network stream
options_gear = {"THREAD_TIMEOUT": 60}
stream = VideoGear(source=return_testvideo_path(),
**options_gear).start()
# define single server
server = NetGear(pattern=pattern,
port=["5556", "5557", "5558"],
logging=True,
**options)
# define a three unique clients
client_1 = NetGear(port="5556",
pattern=pattern,
receive_mode=True,
logging=True,
**options)
client_2 = NetGear(port="5557",
pattern=pattern,
receive_mode=True,
logging=True,
**options)
client_3 = NetGear(port="5558",
pattern=pattern,
receive_mode=True,
logging=True,
**options)
i = 0
while i < random.randint(10, 100):
frame_client = stream.read()
i += 1
# check if input frame is valid
assert not (frame_client is None)
# send frame from 1 server to multiple clients
server.send(frame_client)
frame_1 = client_1.recv()
server.send(frame_client)
frame_2 = client_2.recv()
server.send(frame_client)
frame_3 = client_3.recv()
# check if received frames from server exactly matches input frame
assert np.array_equal(frame_1, frame_client)
assert np.array_equal(frame_2, frame_client)
assert np.array_equal(frame_3, frame_client)
except Exception as e:
if isinstance(e, (ZMQError, ValueError, RuntimeError, queue.Empty)):
pytest.xfail(str(e))
else:
pytest.fail(str(e))
finally:
# clean resources
if not (stream is None):
stream.stop()
if not (server is None):
server.close()
if not (client_1 is None):
client_1.close()
if not (client_2 is None):
client_1.close()
if not (client_3 is None):
client_1.close()