class CameraSource(VideoSource):
"""Process for controlling a camera.
Cameras currently implemented:
======== ===========================================
Ximea Add some info
Avt Add some info
======== ===========================================
Parameters
----------
camera_type : str
specifies type of the camera (currently supported: 'ximea', 'avt')
downsampling : int
specifies downsampling factor for the camera.
Returns
-------
"""
""" dictionary listing classes used to instantiate camera object."""
def __init__(self,
camera_type,
*args,
downsampling=1,
roi=(-1, -1, -1, -1),
max_buffer_length=1000,
**kwargs):
""" """
super().__init__(*args, **kwargs)
self.cam = None
self.camera_type = camera_type
self.downsampling = downsampling
self.roi = roi
self.max_buffer_length = max_buffer_length
self.state = None
self.ring_buffer = None
def retrieve_params(self, messages):
while True:
try:
param_dict = self.control_queue.get(timeout=0.0001)
self.state.params.values = param_dict
for param, value in param_dict.items():
ms = self.cam.set(param, value)
try:
messages.extend(list(ms))
except TypeError:
pass
except Empty:
break
def run(self):
"""
After initializing the camera, the process constantly does the
following:
- read control parameters from the control_queue and set them;
- read frames from the camera and put them in the frame_queue.
"""
if self.state is None:
self.state = CameraControlParameters()
try:
CameraClass = camera_class_dict[self.camera_type]
self.cam = CameraClass(downsampling=self.downsampling,
roi=self.roi)
except KeyError:
raise Exception("{} is not a valid camera type!".format(
self.camera_type))
camera_messages = list(self.cam.open_camera())
[self.message_queue.put(m) for m in camera_messages]
prt = None
while True:
# Kill if signal is set:
self.kill_event.wait(0.0001)
if self.kill_event.is_set():
break
# Try to get new parameters from the control queue:
messages = []
if self.control_queue is not None:
self.retrieve_params(messages)
# Grab the new frame, and put it in the queue if valid:
arr = self.cam.read()
if self.rotation:
arr = np.rot90(arr, self.rotation)
res_len = int(
round(self.state.framerate * self.state.ring_buffer_length))
if res_len > self.max_buffer_length:
res_len = self.max_buffer_length
self.message_queue.put("W:Replay buffer too big, make the plot"
" time range smaller for full replay"
" capabilities")
if self.ring_buffer is None or res_len != self.ring_buffer.length:
self.ring_buffer = RingBuffer(res_len)
if self.state.paused:
self.message_queue.put("I:Ring_buffer_size:" +
str(self.ring_buffer.length))
if self.ring_buffer.arr is not None:
self.frame_queue.put(self.ring_buffer.get_most_recent())
else:
self.message_queue.put(
"E:camera paused before any frames acquired")
prt = None
elif self.state.replay and self.state.replay_fps > 0:
messages.append("I:Replaying between {} and {} of {}".format(
*self.state.replay_limits, self.ring_buffer.length))
old_fps = self.framerate_rec.current_framerate
if old_fps is not None:
self.ring_buffer.replay_limits = (
int(round(self.state.replay_limits[0] * old_fps)),
int(round(self.state.replay_limits[1] * old_fps)),
)
try:
self.frame_queue.put(self.ring_buffer.get())
except ValueError:
pass
delta_t = 1 / self.state.replay_fps
if prt is not None:
extrat = delta_t - (time.process_time() - prt)
if extrat > 0:
time.sleep(extrat)
prt = time.process_time()
else:
prt = None
if arr is not None:
try:
self.ring_buffer.put(arr)
except AttributeError:
pass
# If the queue is full, arrayqueues should print a warning!
if self.frame_queue.queue.qsize() < self.n_consumers + 2:
self.frame_queue.put(arr)
else:
messages.append("W:Dropped frame")
self.update_framerate()
for m in messages:
self.message_queue.put(m)
self.cam.release()
def run(self):
"""
After initializing the camera, the process constantly does the
following:
- read control parameters from the control_queue and set them;
- read frames from the camera and put them in the frame_queue.
"""
if self.state is None:
self.state = CameraControlParameters()
try:
CameraClass = camera_class_dict[self.camera_type]
self.cam = CameraClass(downsampling=self.downsampling,
roi=self.roi)
except KeyError:
raise Exception("{} is not a valid camera type!".format(
self.camera_type))
camera_messages = list(self.cam.open_camera())
[self.message_queue.put(m) for m in camera_messages]
prt = None
while True:
# Kill if signal is set:
self.kill_event.wait(0.0001)
if self.kill_event.is_set():
break
# Try to get new parameters from the control queue:
messages = []
if self.control_queue is not None:
self.retrieve_params(messages)
# Grab the new frame, and put it in the queue if valid:
arr = self.cam.read()
if self.rotation:
arr = np.rot90(arr, self.rotation)
res_len = int(
round(self.state.framerate * self.state.ring_buffer_length))
if res_len > self.max_buffer_length:
res_len = self.max_buffer_length
self.message_queue.put("W:Replay buffer too big, make the plot"
" time range smaller for full replay"
" capabilities")
if self.ring_buffer is None or res_len != self.ring_buffer.length:
self.ring_buffer = RingBuffer(res_len)
if self.state.paused:
self.message_queue.put("I:Ring_buffer_size:" +
str(self.ring_buffer.length))
if self.ring_buffer.arr is not None:
self.frame_queue.put(self.ring_buffer.get_most_recent())
else:
self.message_queue.put(
"E:camera paused before any frames acquired")
prt = None
elif self.state.replay and self.state.replay_fps > 0:
messages.append("I:Replaying between {} and {} of {}".format(
*self.state.replay_limits, self.ring_buffer.length))
old_fps = self.framerate_rec.current_framerate
if old_fps is not None:
self.ring_buffer.replay_limits = (
int(round(self.state.replay_limits[0] * old_fps)),
int(round(self.state.replay_limits[1] * old_fps)),
)
try:
self.frame_queue.put(self.ring_buffer.get())
except ValueError:
pass
delta_t = 1 / self.state.replay_fps
if prt is not None:
extrat = delta_t - (time.process_time() - prt)
if extrat > 0:
time.sleep(extrat)
prt = time.process_time()
else:
prt = None
if arr is not None:
try:
self.ring_buffer.put(arr)
except AttributeError:
pass
# If the queue is full, arrayqueues should print a warning!
if self.frame_queue.queue.qsize() < self.n_consumers + 2:
self.frame_queue.put(arr)
else:
messages.append("W:Dropped frame")
self.update_framerate()
for m in messages:
self.message_queue.put(m)
self.cam.release()