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()