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()
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_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 __init__(self): self.client = NetGear(address="192.168.0.10", port="5566", protocol='tcp', pattern=1, logging=True, receive_mode=True, **options)
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 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 __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 __init__(self, ip='192.168.10.50', port_1=10000, port_2=5454): self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.server_address = (ip, port_1) self.sock.bind(self.server_address) self.client = NetGear(address=ip, port=port_2, protocol='tcp', pattern=0, receive_mode=True, logging=True, flag=0, copy=False, track=False)
def video_stream(self): """ Creates a NetGear socket (TCP for network protocol) to handle video stream from server. Args: self.systemStatus (string): Used to determine if the system needs to shutdown or go to standby. Returns: None """ hostname = socket.gethostname() IPAddr = socket.gethostbyname(hostname) # define tweak flags options = {"compression_format": ".jpg", "compression_param": cv2.IMREAD_COLOR} # Define Netgear Client at given IP address and define parameters # !!! change following IP address '192.168.x.xxx' with yours !!! self.NetGearclient = NetGear( address=IPAddr, port="5454", protocol="tcp", pattern=0, receive_mode=True, **options ) self.lmain.grid(row=0, column=1, rowspan=3) # loop over while True: if(self.systemStatus == "Online"): # receive frames from network frame = self.NetGearclient.recv() # check for received frame if Nonetype if frame is None: break thread = threading.Thread(target = self.updateVideoWindow, args = (frame, )) thread.start()
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 run_camera(input_str, address, port, protocol, pattern=0, fps=25, client_plugins={}): """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 options = {'THREADED_QUEUE_MODE': False} if address == '': address = None # Open any video stream; `framerate` here is just for picamera stream = VideoGear(source=input, framerate=fps, **options).start() # server = NetGear() # Locally netgear_options = {'max_retries': 10, 'request_timeout': 10} server = NetGear(address=address, port=port, protocol=protocol, pattern=pattern, receive_mode=False, logging=True, **netgear_options) # Plugin parsing c_plugs = load_image_detector_client_plugins(client_plugins) # infinite loop until [Ctrl+C] is pressed _prev_frame = None while True: # Sleep time.sleep(0.02) # Client plugins - before run_image_detector_plugins_before(client_plugins, 'client', None, None, _prev_frame) try: frame = stream.read() # check if frame is None if frame is None: logger.error('No frame available') break # Client plugins - after run_image_detector_plugins_after(client_plugins, 'client', _conditional_send, [server, frame, c_plugs], np.copy(frame)) _prev_frame = frame # send frame to server # server.send(frame) except KeyboardInterrupt: # break the infinite loop break # safely close video stream stream.stop()
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 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()
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_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 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 zmq_sender(zmq_args): stream = VideoGear(source=RESOURCE_PATH + '/tests/walking_test_5s.mp4', framerate=zmq_args['fps']).start() server = NetGear(address=zmq_args['ip'], port=zmq_args['port'], protocol=zmq_args['protocol'], pattern=0, receive_mode=False, logging=True) yield (stream, server) # Close stream.stop()
class VideoCamera(object): def __init__(self): self.BC = BirdCamera() options = {'flag' : 0, 'copy' : False, 'track' : False, 'compression_param':cv2.IMREAD_COLOR} self.client = NetGear(address = '192.168.2.71', port = '5555', protocol = 'tcp', pattern = 0, receive_mode = True, logging = True, **options) self.grabbed = True self.frame = self.client.recv() self.lock = threading.Lock() threading.Thread(target=self.update, args=()).start() def __del__(self): self.client.close() def get_frame(self): with self.lock: if self.frame is not None: image = self.frame ret, jpeg = cv2.imencode('.jpg', image) return jpeg.tobytes() else: return None def update(self): while True: with self.lock: frame = self.client.recv() self.BC.processimages(frame) # for location in self.BC.objectscurrentframe: # cv2.rectangle(frame , ( int(location[0] - vert / 4), int(location[1] - vert / 4)), (int(location[0] + vert / 4), int(location[1] + vert / 4)), (255, 255, 255)) concat_frame = np.concatenate((self.BC.fgmask,self.BC.imdil, self.BC._reduceframe(frame)),axis=0) self.frame = concat_frame if self.frame is not None: self.grabbed = True else: self.grabbed = False
def __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)
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()
def create_netgear(self): options = {'compression_param': cv2.IMREAD_COLOR} netgear = NetGear(address=self.server.InternalIPAddress, port=self.server.PortNumber, receive_mode=True, protocol='tcp', **options) print( colored( "Camera " + str(self.camera.CameraID) + ": Netgear established.", self.color)) print( colored( "Camera " + str(self.camera.CameraID) + ": Listening for connection...", self.color)) return netgear
class server: def __init__(self, ip='192.168.10.50', port_1=10000, port_2=5454): self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.server_address = (ip, port_1) self.sock.bind(self.server_address) self.client = NetGear(address=ip, port=port_2, protocol='tcp', pattern=0, receive_mode=True, logging=True, flag=0, copy=False, track=False) def receive_data(self, image_capture=True): if image_capture: frame = self.client.recv() data, address = self.sock.recvfrom(100) # blocking IO data = json.loads(data) return frame, data, address
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()))
import socket import cv2 import numpy as np from vidgear.gears import NetGear #define netgear client with `receive_mode = True` and default settings server = NetGear(address='127.0.0.1', port='35560', receive_mode=True) # infinite loop while True: frame = server.recv() if frame is None: break cv2.namedWindow('Output Frame', cv2.WINDOW_GUI_NORMAL) cv2.setWindowProperty('Output Frame', cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN) cv2.moveWindow('Output Frame', 100, 400) cv2.resizeWindow('Output Frame', 400, 255) cv2.imshow("Output Frame", frame) key = cv2.waitKey(1) & 0xFF if key == ord("q"): break # close output window cv2.destroyAllWindows() # safely close client server.close()
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}")
##!/usr/bin/env python """ example taken from: https://abhitronix.github.io/vidgear/gears/netgear/usage/ """ from vidgear.gears import VideoGear from vidgear.gears import NetGear if __name__ == "__main__": # open any valid video stream(for e.g `test.mp4` file) stream = VideoGear(enablePiCamera=True, source='test.mp4').start() # Define Netgear Server with default parameters server = NetGear() # 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)
import logging import sys logger = logging.getLogger(__name__) logger.setLevel(level = logging.INFO) handler = logging.FileHandler("/data/log/tb_cam.log") handler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) #activate multiserver_mode options = {'multiserver_mode': False} #change following IP address '192.168.1.xxx' with Client's IP address and assign unique port address(for e.g 5566). server = NetGear(address = "your ip", port = '5566', protocol = 'tcp', pattern = 1, receive_mode = False, logging=True, **options) # and keep rest of settings similar to Client cur_path = sys.path[0] # parameters for loading data and images detection_model_path = cur_path+'/emotion_rec/haarcascade_files/haarcascade_frontalface_default.xml' emotion_model_path = cur_path+'/emotion_rec/models/_mini_XCEPTION.102-0.66.hdf5' preds=[] # hyper-parameters for bounding boxes shape # loading models face_detection = cv2.CascadeClassifier(detection_model_path) emotion_classifier = load_model(emotion_model_path, compile=False) EMOTIONS = ["angry" ,"disgust","scared", "happy", "sad", "surprised","neutral"] feelings_faces = [] emoji_face = [] for index, emotion in enumerate(EMOTIONS):
"compression_format": ".jpg", "compression_param": ( cv2.IMREAD_COLOR, [ cv2.IMWRITE_JPEG_QUALITY, 70, cv2.IMWRITE_JPEG_PROGRESSIVE, True, cv2.IMWRITE_JPEG_OPTIMIZE, True, ], ), } Controller.server = NetGear(address=args.address, receive_mode=True, logging=True, pattern=1, **netgear_options) app = web() # run this app on Uvicorn server at address http://localhost:8001/ uvicorn.run(app, host='0.0.0.0', port=8001) # session.close() # close app safely web.shutdown()
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!')
# 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()