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