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