def _streamVideo(self, device):
frame_index = 1
fps = 0
counter = 0
cap = cv2.VideoCapture(self.videosource)
cap.set(3, self.width)
cap.set(4, self.height)
cap.set(5, self.frame)
payload = Payload(device, self.width, self.height)
start_time = time.time()
try:
while True:
_, image = cap.read()
payload.setPayloadParam(time.time(), image, frame_index)
self.pub_socket.send(payload.get())
seconds = time.time() - start_time
if seconds > 1:
fps = counter
counter = 0
start_time = time.time()
outstr = "Frames: {}, FPS: {}".format(frame_index, fps)
sys.stdout.write('\r' + outstr)
counter = counter + 1
frame_index = frame_index + 1
except (KeyboardInterrupt, SystemExit):
print('Exit due to keyboard interrupt')
except Exception as ex:
print('Python error with no Exception handler:')
print('Traceback error:', ex)
traceback.print_exc()
finally:
cap.release()
sys.exit(0)
class StartThreadToStream:
"""
Using new thread to send the the frame
"""
def __init__(self, pub_socket, device, resolution, backend):
self.backend = backend
self.newpayload = False
self.frame = None
self.frame_index = 1
self.monotonic = 0
self.pub_socket = pub_socket
self._stop = False
self._thread = threading.Thread(target=self._run, args=())
self._thread.daemon = True
self._thread.start()
self.payload = Payload(device, resolution[0], resolution[1], "gray")
def _run(self):
while not self._stop:
if self.newpayload == True:
self.newpayload = False
frame = numpy.ascontiguousarray(self.frame)
self.payload.setPayloadParam(
self.backend.get_synced_pupil_time(self.monotonic),
frame,
self.frame_index,
)
self.pub_socket.send(self.payload.get())
else:
sleep(0.001)
def dataready(self, frame, frame_index, time_monotonic):
self.frame = frame
self.frame_index = frame_index
self.monotonic = time_monotonic
self.newpayload = True
def close(self):
self._stop = True
frame = 1
fps = 0
index = 0
cap.setResolution(width, height)
cap.start()
payload = Payload("world", width, height, format="yuv")
image = cap.read()
width = image.shape[1]
height = image.shape[0]
start_time = image_read_time = time()
try:
while True:
image = cap.grab()
latency = time() - image_read_time
payload.setPayloadParam(time(), image, index)
msg_streamer.send(payload.get())
if time() - start_time > 1:
fps = frame
frame = 0
start_time = time()
outstr = "Frames: {}, FPS: {}, Frame Read latency: {:.6f} ".format(
index, fps, latency)
sys.stdout.write("\r" + outstr)
frame = frame + 1
index = index + 1
image_read_time = time()
except Exception:
exp = traceback.format_exc()
print(exp)
finally:
cap.release()
def _streamVideo(self):
try:
logging.info("Using default camera source:{}".format(
self.videosource))
logging.info(
"Setting video capture parameters. Height:{}, Width:{}, FPS:{}"
.format(self.height, self.width, self.frame))
logging.info("Starting the stream for device:{}.".format(
self.device))
frame_index = 1
fps = 0
counter = 1
cap = cv2.VideoCapture(self.videosource)
if not cap.isOpened():
logging.critical(
"Cannot open camera for camera index {}".format(
self.videosource))
exit(0)
cap.set(3, self.width)
cap.set(4, self.height)
cap.set(5, self.frame)
ret, frame = cap.read()
if not ret:
logging.critical(
"Can't receive frame (stream end?). Exiting ...")
exit(0)
hertz = cap.get(5)
width = frame.shape[1]
height = frame.shape[0]
payload = Payload("world", width, height)
if self.width != width or self.height != height or self.frame != hertz:
logging.info(
"Camera changed capture parameters. Height:{}, Width:{}, FPS:{}"
.format(height, width, hertz))
self.height = height
self.width = width
self.frame = hertz
payload = Payload(self.device, self.width, self.height)
start_time = time()
image_read_time = time()
while self.start_publishing == True:
_, image = cap.read()
latency = time() - image_read_time
payload.setPayloadParam(
self.get_synced_pupil_time(monotonic()), image,
frame_index)
self.msg_streamer.send(payload.get())
seconds = time() - start_time
if seconds > 1:
fps = counter
counter = 0
start_time = time()
outstr = "Frames: {}, FPS: {}, Frame Read latency: {}".format(
frame_index, fps, latency)
sys.stdout.write("\r" + outstr)
counter = counter + 1
frame_index = frame_index + 1
image_read_time = time()
except (KeyboardInterrupt, SystemExit):
logging.info("Exit due to keyboard or SystemExit interrupt")
except Exception:
exp = traceback.format_exc()
logging.error(exp)
finally:
logging.info("Stopping the stream for device: {}.".format(
self.device))
cap.release()
logging.info("Total Published frames: {}, FPS:{}.".format(
frame_index, fps))
#rawCapture = PiYUVArray(camera, size=resolution)
stream = camera.capture_continuous(rawCapture,
format="rgb", use_video_port=True)
frame_counter_per_sec = 0
frame_index = 1
start_time = time.time()
streamimage = StartThreadToStream(pub_socket)
payload = Payload("world", resolution[0], resolution[1])
fps = 0
try:
for f in stream:
# grab the frame from the stream and clear the stream in
# preparation for the next frame
frame = f.array
payload.setPayloadParam(time.time(), frame, frame_index)
streamimage.dataready(payload.get()) # give it to StartThreadToStream to publish
#pub_socket.send(payload.get()) # publish here
seconds = time.time() - start_time
if seconds > 1:
fps = frame_counter_per_sec
frame_counter_per_sec = 0
start_time = time.time()
outstr = "Frames: {}, FPS: {}".format(frame_index, fps)
sys.stdout.write('\r'+ outstr)
frame_counter_per_sec = frame_counter_per_sec + 1
frame_index = frame_index + 1
rawCapture.truncate(0)
except (KeyboardInterrupt, SystemExit):
print('Exit due to keyboard interrupt')
except Exception as ex:
print('Python error with no Exception handler:')
