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(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_server_reliablity(options):
"""
Testing validation function of WebGear API
"""
server = None
stream = None
frame_client = None
try:
# define params
server = NetGear(
pattern=1,
port=[5585] if "multiclient_mode" in options.keys() else 6654,
logging=True,
**options)
stream = cv2.VideoCapture(return_testvideo_path())
i = 0
while i < random.randint(10, 100):
(grabbed, frame_client) = stream.read()
i += 1
# check if input frame is valid
assert not (frame_client is None)
# send frame without connection
server.send(frame_client)
server.send(frame_client)
except Exception as e:
if isinstance(e, (RuntimeError)):
pytest.xfail("Reconnection ran successfully.")
else:
logger.exception(str(e))
finally:
# clean resources
if not (stream is None):
stream.release()
if not (server is None):
server.close()
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_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_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 VideoStream():
global command_client
global driver
global recv_inst
print("Started")
driver = Driver()
recv_inst = True
command_client = socket.socket()
command_client.connect((host, command_port))
Thread(target=steer).start()
sleep(1)
cam = cv2.VideoCapture(0)
client = NetGear(address=host,
port=video_port,
protocol='tcp',
pattern=0,
recieve_mode=False,
logging=False)
cam.set(3, 320)
cam.set(4, 240)
#cam.set(cv2.CAP_PROP_FPS, 10)
while recv_inst:
ret, frame = cam.read()
if frame is None:
break
cv2.imshow("Car Cam", frame)
client.send(frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cam.release()
client.close()
command_client.close()
cv2.destroyAllWindows()
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()
def run_camera(input_str, address, port, protocol):
if input_str.isdigit():
input = int(input_str)
else: input = input_str
# Open any video stream
stream = VideoGear(source=input).start()
# server = NetGear() # Locally
server = NetGear(address=address, port=port, protocol=protocol,
pattern=0, receive_mode=False, logging=True)
# infinite loop until [Ctrl+C] is pressed
while True:
try:
frame = stream.read()
# read frames
# check if frame is None
if frame is None:
# if True break the infinite loop
break
# do something with frame here
# send frame to server
server.send(frame)
except KeyboardInterrupt:
# break the infinite loop
break
# safely close video stream
stream.stop()
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()
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 run_camera(input_str, address, port, protocol, pattern=0, fps=25):
"""Runs the camera, sends messages
Args:
input_str (str): Path to video file **OR** an `int` for camera input
address (str): URL of `OpenCV` server
port (int): Port of `OpenCV` server
protocol (str): Protocol of of `OpenCV` server
pattern (int, optional): ZMQ Pattern. 0=`zmq.PAIR`, 1=`zmq.REQ/zmq.REP`; 2=`zmq.PUB,zmq.SUB`. Defaults to 0.
fps (int, optional): Framerate for video capture. Defaults to 25.
"""
if input_str.isdigit():
input = int(input_str)
else:
input = input_str
# Open any video stream; `framerate` here is just for picamera
stream = VideoGear(source=input, framerate=fps).start()
# server = NetGear() # Locally
server = NetGear(address=address,
port=port,
protocol=protocol,
pattern=pattern,
receive_mode=False,
logging=True)
# infinite loop until [Ctrl+C] is pressed
while True:
# Sleep
time.sleep(0.02)
try:
frame = stream.read()
# check if frame is None
if frame is None:
logger.error('No frame available')
break
# send frame to server
server.send(frame)
except KeyboardInterrupt:
# break the infinite loop
break
# safely close video stream
stream.stop()
def test_bidirectional_mode(pattern, 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(pattern=pattern,
receive_mode=True,
logging=True,
**options)
server = NetGear(pattern=pattern, 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.exception(str(e))
else:
pytest.fail(str(e))
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))
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_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))
class Vedio():
def __init__(self):
self.server = NetGear(
address='192.168.0.100',
port='5054',
protocol='udp',
pattern=0,
receive_mode=False,
logging=True) #Define netgear server at your system IP address.
sub = rospy.Subscriber("/cv_camera/image_raw", Image, self.get_image)
self.bridge = CvBridge()
self.image_org = None
rospy.spin()
def get_image(self, img):
try:
self.image_org = self.bridge.imgmsg_to_cv2(img, "bgr8")
self.frame = np.array(self.image_org, dtype=np.uint8)
self.server.send(self.frame)
except CvBridgeError as e:
rospy.logerr(e)
def serverclose(self):
self.server.close()
port="5454",
protocol="tcp",
pattern=0,
logging=True,
**options)
# loop over until KeyBoard Interrupted
key = "a"
while True:
try:
# read frames from stream
frame = cam.read()
# send frame to compute_node
processed_frame = client.send(frame[:, crop_start:crop_end, :],
message=key)
if not (processed_frame is None):
cv2.imshow("Output Frame", processed_frame)
# check for 'q' key if pressed
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
client.send(frame[:, crop_start:crop_end, :], message=key)
break
except KeyboardInterrupt:
break
# close output window
# loop over until KeyBoard Interrupted
while True:
try:
# read frames from stream
frame = stream.read()
# check for frame if Nonetype
if frame is None:
break
# {do something with the frame here}
# send frame to server
server.send(frame)
except KeyboardInterrupt:
break
# safely close video stream
stream.stop()
# safely close server
server.close()
"""
from imutils import build_montages
from datetime import datetime
import numpy as np
import imagezmq
import argparse
def main(args):
# Start capturing live Monitor screen frames with default settings
# time_delay for warming the camera up
pi_options = {
"exposure_mode": "auto",
"iso": 800,
"exposure_compensation": 5,
"awb_mode": "horizon"
}
stream = PiGear(time_delay=2,
rotation=args.rotation,
resolution=args.resolution,
framerate=args.framerate,
logging=args.logging,
**pi_options).start()
server_options = {
'compression_format': '.jpg',
'compression_param':
[cv2.IMWRITE_JPEG_QUALITY, args.compression_quality],
'flag': 1,
'max_retries': 100
}
server = NetGear(address=args.address,
port=args.port,
protocol='tcp',
bidirectional_mode=True,
pattern=1,
logging=False,
**server_options)
# loop over until KeyBoard Interrupted
frame_counter = 0
start_time = None
while True:
try:
# read frames from stream
frame = stream.read()
if start_time is None:
start_time = time.time()
# check for frame if Nonetype
if frame is None:
break
# send frame to server
recv_data = server.send(frame)
# print data just received from Client
if not (recv_data is None):
print(recv_data)
# Baudrate, max 115200 bits per seconds communication with arduino mega
ser = serial.Serial('/dev/ttyACM0', 115200)
targetCoordinates = recv_data[0]
fromArduino = 'C'
while fromArduino == 'C':
if not targetCoordinates:
ser.write('A'.encode())
fromArduino = ser.read()
else:
xCoord = targetCoordinates[0]
yCoord = targetCoordinates[1]
if (xCoord > 50):
ser.write('L'.encode())
elif (xCoord < -50):
ser.write('R'.encode())
elif (xCoord):
ser.write('F'.encode())
elif (yCoord):
ser.write('T'.encode())
elif ((xCoord > -50) and (xCoord < 50)):
if (yCoord > 150):
ser.write('F'.encode())
elif (yCoord < -150):
ser.write('T'.encode())
else:
time.sleep(0.05)
else:
ser.write('A'.encode())
fromArduino = ser.read()
except KeyboardInterrupt:
break
frame_counter += 1
# safely close video stream
stream.stop()
# safely close server
server.close()
elapsed_time = time.time() - start_time
print(f"sender avg FPS: {frame_counter/elapsed_time}")
# import libraries
from vidgear.gears import NetGear
import cv2
stream = cv2.VideoCapture(2)
options = {'flag' : 0, 'copy' : False, 'track' : False}
server = NetGear(address = '192.168.0.101', port = '5454', protocol = 'tcp', pattern = 0, receive_mode = False, logging = True, **options) #Define netgear server at your system IP address.
while True:
try:
(grabbed, frame) = stream.read()
if not grabbed:
break
server.send(cv2.resize(frame, (160,120)))
except KeyboardInterrupt:
break
stream.release()
server.close()
class piclient:
def __init__(self,
ip='192.168.10.50',
port_1=10000,
port_2=5454,
time_delay=1,
frame_rate=25,
img_resolution=(320, 240)):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server_address = (ip, port_1)
self.options = {
"hflip": True,
"exposure_mode": "auto",
"iso": 800,
"exposure_compensation": 15,
"awb_mode": "horizon",
"sensor_mode": 0
}
self.stream = PiGear(resolution=img_resolution,
framerate=frame_rate,
time_delay=time_delay,
logging=True,
**self.options).start()
self.server = NetGear(address=ip,
port=port_2,
protocol='tcp',
pattern=0,
receive_mode=False,
logging=True,
flag=0,
copy=False,
track=False)
def send_data(self, image_capture=True, json_data={"data": None}):
if image_capture:
try:
frame = self.stream.read()
self.server.send(frame)
except:
print('frame sending failed!')
try:
send_data = json.dumps(json_data)
s_text = str(send_data)
message = bytes(s_text, encoding='utf-8')
self.sock.sendto(message, self.server_address)
except:
print('data sending failed!')
#pass
def close(self):
self.stream.stop()
self.server.close()
print('connection closed!')
cv2.rectangle(frameClone, (fX, fY), (fX + fW, fY + fH),
(255, 255, 0), 1)# BGR
for c in range(0, 3):
frameClone[10:70, 240:300, c] = emoji_face[:, :, c] * \
(emoji_face[:, :, 3] / 255.0) + frameClone[10:70,
240:300, c] * (1.0 - emoji_face[:, :, 3] / 255.0)
time_of_calc = round((time.time()-time_of_calc), 4)*1000
cv2.putText(frameClone, "FPS: %sfps" % current_fps, (10, 10), cv2.FONT_HERSHEY_COMPLEX_SMALL, 0.4, (255,255,0), 1)
cv2.putText(frameClone, "ALL_TIME: %sms" % time_of_all, (10, 20), cv2.FONT_HERSHEY_COMPLEX_SMALL, 0.4, (255,255,0), 1)
cv2.putText(frameClone, "CALC_TIME: %sms" % time_of_calc, (10, 30), cv2.FONT_HERSHEY_COMPLEX_SMALL, 0.4, (255,255,0), 1)
cv2.putText(frameClone, "TRANS_TIME: %sms" % time_of_trans, (10, 40), cv2.FONT_HERSHEY_COMPLEX_SMALL, 0.4, (255,255,0), 1)
#if cv2.waitKey(1) & 0xFF == ord('q'):
# break
time_of_trans = time.time()
try:
server.send(frameClone)
except:
pass
fps_num = fps_num + 1
#cv2.imshow('your_face', frameClone)
#cv2.imshow("Probabilities", canvas)
time_of_trans = round((time.time()-time_of_trans), 4)*1000
time_of_all = time_of_calc + time_of_trans
print "time_of_all: %sms, time_of_calc: %sms,time_of_trans: %sms, current_fps: %sfps" % (time_of_all, time_of_calc, time_of_trans, current_fps)
logger.info("time_of_all: %sms, time_of_calc: %sms,time_of_trans: %sms, current_fps: %sfps" % (time_of_all, time_of_calc, time_of_trans, current_fps))
except:
pass
camera.release()
server.close()
#cv2.destroyAllWindows()
protocol="tcp",
) # Define netgear server with default settings
# infinite loop until [Ctrl+C] is pressed
while True:
try:
frame = stream.read()
# read frames
# check if frame is None
if frame is None:
# if True break the infinite loop
break
# do something with frame here
timestamp = time.time_ns()
print(timestamp)
# send frame to server
# print(frame)
server.send(frame, message=timestamp)
except KeyboardInterrupt:
# break the infinite loop
break
# safely close video stream
stream.stop()
# safely close server
server.close()
client = NetGear(address=host,
port=port,
protocol='tcp',
pattern=1,
receive_mode=False,
logging=True,
**options)
cam.set(3, 320)
cam.set(4, 240)
driver = Driver()
while True:
ret, frame = cam.read()
if frame is None:
break
cv2.imshow("Webcam", frame)
data = client.send(frame)
if data == "quit":
driver.drive(0, 0, 90)
break
elif data != " ":
t = data['throttle']
s = data['speed']
a = data['angle']
driver.drive(t, s, a)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cam.release()
cv2.destroyAllWindows()
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()
def videoStream(server, in_q):
"""
Creates a Netgear socket (TCP for network protocol) to stream video to the client.
Allows us to use compression and other protocols for the video stream.
Args:
server.clients (list): List of connected clients. Used to get IP of user client (uses a different port).
in_q (Queue): Queue shared between videoStream and the visionSystem (allows for thread-safe communication).
Returns:
None
"""
ipOfClient = server.clients[-1].getpeername()
#10 frames a sec is fine for the video stream
#If not, you are welcome to increase (problems with the GUI appear if you do)
frame_rate = 10
prev = 0
# define tweak flags
options = {
"compression_format": ".jpg",
"compression_param": [cv2.IMWRITE_JPEG_QUALITY, 50],
}
VidGearServer = NetGear(address=ipOfClient[0],
port="5454",
protocol="tcp",
pattern=0,
**options)
# loop over until KeyBoard Interrupted
while True:
if (server.systemStatus == "Online"):
try:
time_elapsed = time.time() - prev
if (time_elapsed > 1. / frame_rate):
# read frames from stream
frame = in_q.get()
#print(frame)
prev = time.time()
VidGearServer.send(frame)
except KeyboardInterrupt:
break
elif (server.systemStatus == "Offline"):
VidGearServer.close()
return