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_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))
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
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))
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_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(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_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_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_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_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 zmq_receiver(zmq_args):
client = NetGear(address=zmq_args['ip'], port=zmq_args['port'],
protocol=zmq_args['protocol'],
pattern=0, receive_mode=True, logging=True)
yield client
# Close
client.close()
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_ports(server_ports, client_ports, options):
"""
Test made to fail on wrong port values
"""
if server_ports:
server = NetGear(pattern=1, port=server_ports, logging=True, **options)
server.close()
else:
client = NetGear(
port=client_ports, pattern=1, receive_mode=True, logging=True, **options
)
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_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_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_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_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))
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()
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
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()
# HOST = '127.0.0.1'
# PORT = 5180
# server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# server_socket.bind((HOST, PORT))
# server_socket.listen()
# client_socket, addr = server_socket.accept()
# print('Connected by', addr)
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}")
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!')
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
# 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()