def __init__(self, media): self.writer = None self.media = media self.config = Configuration() self.file_name = None self.index = 0 self.compress = 0
class Image_recorder: def __init__(self, media): self.writer = None self.media = media self.config = Configuration() self.file_name = None self.index = 0 def start(self, shape, path=None, fps=30): # TODO manage multiple record # manage only one record at time if self.writer: self.stop() if not path: path = "%s" % (self.config.get_path_save_record()) if not path: path = "./" elif "/" not in path: path = "%s%s" % (self.config.get_path_save_record(), path) if os.path.isfile(path): log.print_function(logger.error, "File already exist %s" % path) return False if not os.path.isdir(path): try: os.makedirs(path) except: pass self.file_name = path logger.info("Start record on path: %s", path) self.media.add_observer(self.write) self.writer = self.write return True def next_filename(self): path = os.path.join(self.file_name, str(self.index).zfill(10) + '.png') self.index += 1 return path def write(self, image): cv2.imwrite(self.next_filename(), image) def get_file_name(self): if not self.file_name: return "" return self.file_name def stop(self): logger.info("Close record on path: %s", self.file_name) self.file_name = None if not self.writer: return False self.media.remove_observer(self.write) self.writer = None return True
def __init__(self, media): self.writer = None self.media = media self.config = Configuration() self.file_name = None self.process = None # create a semaphore to protect when closing ffmpeg self.sem = Semaphore(1)
def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(ImageGenerator, self).__init__() self.media_name = config.name self.run = True self._is_opened = True self._create_params() self.deserialize(self.config.read_media(self.get_name()))
def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(Webcam, self).__init__() self.media_name = config.name self.run = True self.video = None video = cv2.VideoCapture(config.no) if video.isOpened(): self._is_opened = True video.release() self._create_params() self.deserialize(self.config.read_media(self.get_name()))
def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(PygameCam, self).__init__() self.media_name = config.name self.run = True self.video = None self.thread_image = None pygame.init() pygame.camera.init() self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.cam = None self._is_opened = True self.image = None
def __init__(self, config): # Go into configuration/template_media for more information super(Firewire, self).__init__() self.config = Configuration() self.camera = None self.is_streaming = False self.loop_try_open_camera = False self.call_stop = False self.sem_closed = threading.Semaphore() self.cam_guid = config.guid self.cam_no = config.no # the id is guid or no, writing into open_camera self.id = "" self.key_auto_param = "-auto" self.reference_param = {"power": self._power, "transmission": self._transmission} fps = 15 self.sleep_time = 1 / 15.0 self.media_name = config.name self.last_timestamp = -1 self.actual_timestamp = -1 self.count_not_receive = 0 self.max_not_receive = fps * 2 self.buffer_last_timestamp = False self.own_config = config self.is_rgb = config.is_rgb self.is_mono = config.is_mono self.is_format_7 = config.is_format7 self.is_yuv = config.is_yuv self.actual_image = None self.shape = (800, 600) self.count_no_image = 0 self.max_no_image = 120 self.lst_param_shutter = [] self.lst_param_whitebalance = [] if not self.try_open_camera(repeat_loop=3, sleep_time=1): return self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.update_all_property()
def __init__(self, config): # Go into configuration/template_media for more information super(IPC, self).__init__() self.config = Configuration() self.own_config = config self.media_name = config.name if config.device: self.device_name = config.device else: self.device_name = "/tmp/seagoatvision_media.ipc" self._is_opened = True self.run = True self.video = None self.context = zmq.Context() self.subscriber = None self.message = None self._create_params() self.deserialize(self.config.read_media(self.get_name()))
def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(Pygame_cam, self).__init__() self.media_name = config.name self.run = True self.video = None pygame.init() pygame.camera.init() self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.cam = None self.isOpened = True self.image = None
def __init__(self, config): # Go into configuration/template_media for more information super(Firewire, self).__init__() self.config = Configuration() self.camera = None self.is_streaming = False self.loop_try_open_camera = False self.dct_params = {} self.call_stop = False # TODO: this is an hack that cause memory leak self.lst_garbage_camera = [] self.cam_guid = config.guid self.cam_no = config.no # the id is guid or no, writing into open_camera self.id = "" self.key_auto_param = "-auto" fps = 15 self.sleep_time = 1 / 15.0 self.media_name = config.name self.last_timestamp = -1 self.actual_timestamp = -1 self.count_not_receive = 0 self.max_not_receive = fps * 2 self.buffer_last_timestamp = False self.own_config = config self.is_rgb = config.is_rgb self.is_mono = config.is_mono self.is_format_7 = config.is_format7 self.is_yuv = config.is_yuv self.actual_image = None self.shape = (800, 600) self.count_no_image = 0 self.max_no_image = 60 if not self.try_open_camera(repeat_loop=3, sleep_time=1): return self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.update_all_property()
class ImageRecorder: def __init__(self, media): self.writer = None self.media = media self.config = Configuration() self.file_name = None self.index = 0 self.compress = 0 def start(self, shape, path=None, fps=30, compress=0): # TODO manage multiple record # manage only one record at time if self.writer: self.stop() if not path: path = "%s" % (self.config.get_path_save_record()) if not path: path = "./" elif "/" not in path: path = "%s%s" % (self.config.get_path_save_record(), path) if os.path.isfile(path): log.print_function(logger.error, "File already exist %s" % path) return False self.compress = compress if not os.path.isdir(path): try: os.makedirs(path) except: pass self.file_name = path logger.info("Start record on path: %s", path) self.media.add_observer(self.write) self.writer = self.write return True def next_filename(self): path = os.path.join(self.file_name, str(self.index).zfill(10) + '.png') self.index += 1 return path def write(self, image): compress = int(self.compress * 0.09) params = [cv2.cv.CV_IMWRITE_PNG_COMPRESSION, compress] cv2.imwrite(self.next_filename(), image, params) def get_file_name(self): if not self.file_name: return "" return self.file_name def stop(self): logger.info("Close record on path: %s", self.file_name) self.file_name = None if not self.writer: return False self.media.remove_observer(self.write) self.writer = None return True
#! /usr/bin/env python # Copyright (C) 2012 Octets - octets.etsmtl.ca # # This filename is part of SeaGoatVision. # # SeaGoatVision is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from SeaGoatVision.server.core.configuration import Configuration config = Configuration() if config.get_is_show_public_filter(): from public import * from private import *
class Webcam(MediaStreaming): """Return images from the webcam.""" def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(Webcam, self).__init__() self.media_name = config.name self.run = True self.video = None video = cv2.VideoCapture(config.no) if video.isOpened(): self._is_opened = True video.release() self._create_params() self.deserialize(self.config.read_media(self.get_name())) def _create_params(self): self.dct_params = {} default_resolution_name = "800x600" self.dct_resolution = {default_resolution_name: (800, 600), "320x240": (320, 240), "640x480": (640, 480), "1024x768": (1024, 768), "1280x960": (1280, 960), "1280x1024": (1280, 1024)} self.param_resolution = Param( "resolution", default_resolution_name, lst_value=self.dct_resolution.keys()) self.param_resolution.add_notify(self.reload) default_fps_name = "30" self.dct_fps = {default_fps_name: 30, "15": 15, "7.5": 7.5} self.param_fps = Param("fps", default_fps_name, lst_value=self.dct_fps.keys()) self.param_fps.add_notify(self.reload) def open(self): try: shape = self.dct_resolution[self.param_resolution.get()] fps = self.dct_fps[self.param_fps.get()] # TODO check argument video capture self.video = cv2.VideoCapture(self.own_config.no) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, shape[0]) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, shape[1]) self.video.set(cv2.cv.CV_CAP_PROP_FPS, fps) except BaseException as e: log.printerror_stacktrace( logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return MediaStreaming.open(self) def next(self): run, image = self.video.read() if not run: raise StopIteration return image def close(self): MediaStreaming.close(self) if self.video: self.video.release() self._is_opened = False return True
class PygameCam(MediaStreaming): """Return images from the webcam.""" def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(PygameCam, self).__init__() self.media_name = config.name self.run = True self.video = None self.thread_image = None pygame.init() pygame.camera.init() self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.cam = None self._is_opened = True self.image = None def _create_params(self): default_resolution_name = "800x600" self.dct_resolution = {default_resolution_name: (800, 600), "320x240": (320, 240), "640x480": (640, 480), "1024x768": (1024, 768), "1280x960": (1280, 960), "1280x1024": (1280, 1024)} self.param_resolution = Param( "resolution", default_resolution_name, lst_value=self.dct_resolution.keys()) self.param_resolution.add_notify(self.reload) default_fps_name = "30" self.dct_fps = {default_fps_name: 30, "15": 15, "7.5": 7.5} self.param_fps = Param("fps", default_fps_name, lst_value=self.dct_fps.keys()) self.param_fps.add_notify(self.reload) def open(self): try: shape = self.dct_resolution[ self.param_resolution.get()] fps = self.dct_fps[self.param_fps.get()] self.video = pygame.camera.Camera(self.own_config.path, shape) self.video.start() self.thread_image = True thread.start_new_thread(self.update_image, ()) except BaseException as e: log.printerror_stacktrace( logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return MediaStreaming.open(self) def update_image(self): while self.thread_image: image_surface = self.video.get_image() image = pygame.surfarray.pixels3d(image_surface) image = np.rot90(image, 3) copy_image = np.zeros(image.shape, np.float32) copy_image = cv2.cvtColor(image, cv2.cv.CV_BGR2RGB, copy_image) self.image = copy_image def next(self): return self.image def close(self): MediaStreaming.close(self) self.thread_image = False # TODO add semaphore? self.video.stop() self._is_opened = False return True
class IPC(MediaStreaming): """ Return image from IPC socket with ZeroMQ This media is a subscriber of ZeroMQ """ key_ipc_name = "ipc name" def __init__(self, config): # Go into configuration/template_media for more information super(IPC, self).__init__() self.config = Configuration() self.own_config = config self.media_name = config.name if config.device: self.device_name = config.device else: self.device_name = "/tmp/seagoatvision_media.ipc" self._is_opened = True self.run = True self.video = None self.context = zmq.Context() self.subscriber = None self.message = None self._create_params() self.deserialize(self.config.read_media(self.get_name())) def _create_params(self): default_ipc_name = "ipc://%s" % self.device_name self.param_ipc_name = Param(self.key_ipc_name, default_ipc_name) self.param_ipc_name.add_notify(self.reload) def open(self): self.subscriber = self.context.socket(zmq.SUB) self.subscriber.setsockopt(zmq.SUBSCRIBE, b'') device_name = self.param_ipc_name.get() logger.info("Open media device %s" % device_name) self.subscriber.connect(device_name) thread.start_new_thread(self.fill_message, tuple()) # call open when video is ready return MediaStreaming.open(self) def next(self): if not self.subscriber or not self.message: return image = None message = self.message[:] self.message = None lst_pixel = list(bytearray(message)) # the first 2 bytes is width of image len_message = len(lst_pixel) - 2 if len_message: width = (lst_pixel[0] << 8) + lst_pixel[1] if not width: return image = np.array(lst_pixel[2:]) # check if missing pixel and replace by zero diff = len_message % width if diff: image += [0] * (width - diff) image = image.reshape((-1, width)) shape = image.shape if len(shape) < 3 or 3 > shape[2]: # convert in 3 depth, bgr picture image_float = np.array(image, dtype=np.float32) vis2 = cv2.cvtColor(image_float, cv2.COLOR_GRAY2BGR) image = np.array(vis2, dtype=np.uint8) return image def close(self): MediaStreaming.close(self) # TODO need to debug, closing socket create errors and \ # context.term freeze # self.subscriber.close() # self.context.term() self.subscriber = None return True def fill_message(self): try: while self.subscriber: self.message = self.subscriber.recv() except zmq.ContextTerminated: pass finally: self.message = None
class Pygame_cam(Media_streaming): """Return images from the webcam.""" def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(Pygame_cam, self).__init__() self.media_name = config.name self.run = True self.video = None pygame.init() pygame.camera.init() self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.cam = None self.isOpened = True self.image = None def _create_params(self): self.dct_params = {} default_resolution_name = "800x600" self.dct_resolution = {default_resolution_name:(800, 600), "320x240":(320, 240), "640x480":(640, 480), "1024x768":(1024, 768), "1280x960":(1280, 960)} param = Param("resolution", default_resolution_name, lst_value=self.dct_resolution.keys()) param.add_notify_reset(self.reset_property_param) self.dct_params["resolution"] = param default_fps_name = "30" self.dct_fps = {default_fps_name:30, "15":15, "7.5":7.5} param = Param("fps", default_fps_name, lst_value=self.dct_fps.keys()) param.add_notify_reset(self.reset_property_param) self.dct_params["fps"] = param def serialize(self): return {"resolution":self.dct_params.get("resolution").get(), "fps":self.dct_params.get("fps").get()} def deserialize(self, data): if not data: return False if type(data) is not dict: log.print_function(logger.error, "Wrong format data, suppose to be dict into camera %s" % self.get_name()) return False res = data.get("resolution", None) if res: self.dct_params.get("resolution").set(res) res = data.get("fps", None) if res: self.dct_params.get("fps").set(res) return True def open(self): try: shape = self.dct_resolution[self.dct_params.get("resolution").get()] fps = self.dct_fps[self.dct_params.get("fps").get()] self.video = pygame.camera.Camera(self.own_config.path, shape) self.video.start() self.thread_image = True thread.start_new_thread(self.update_image, ()) except Exception as e: log.printerror_stacktrace(logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return Media_streaming.open(self) def update_image(self): while self.thread_image: image_surface = self.video.get_image() image = pygame.surfarray.pixels3d(image_surface) image = np.rot90(image, 3) copy_image = np.zeros(image.shape, np.float32) copy_image = cv2.cvtColor(image, cv2.cv.CV_BGR2RGB, copy_image) self.image = copy_image def next(self): return self.image def close(self): Media_streaming.close(self) self.thread_image = False # TODO add semaphore? self.video.stop() self.isOpened = False return True def get_properties_param(self): return self.dct_params.values() def update_property_param(self, param_name, value): param = self.dct_params.get(param_name, None) if not param: return False param_value = param.get() if value == param_value: return True param.set(value) self.reload() return True def reset_property_param(self, param_name, value): self.reload() return True
#! /usr/bin/env python # Copyright (C) 2012-2014 Octets - octets.etsmtl.ca # # This file is part of SeaGoatVision. # # SeaGoatVision is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from SeaGoatVision.server.core.configuration import Configuration config = Configuration() if config.get_is_show_public_filter(): from public import * if config.get_is_show_private_filter(): from private import *
from SeaGoatVision.commons import log from SeaGoatVision.server.core.filter import Filter from SeaGoatVision.server.core.configuration import Configuration from cpp_code import * import numpy as np from python_code import * import scipy.weave.ext_tools as ext_tools # import sys logger = log.get_logger(__name__) BUILD_DIR = 'build' RELOAD_DIR = os.path.join('build', 'reload') has_configure = False has_destroy = False config = Configuration() def import_all_cpp_filter(cppfiles, cpptimestamps, module, file, extra_link_arg=[], extra_compile_arg=[]): """ This method finds and compile every c++ filters If a c++ file changed, the file must be recompiled in a new .so file """ # param : # module like sys.modules[__name__] # file is __file__ from __init__.py
class Webcam(MediaStreaming): """Return images from the webcam.""" def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(Webcam, self).__init__() self.media_name = config.name self.run = True self.video = None video = cv2.VideoCapture(config.no) if video.isOpened(): self._is_opened = True video.release() self._create_params() self.deserialize(self.config.read_media(self.get_name())) def _create_params(self): self.dct_params = {} default_resolution_name = "800x600" self.dct_resolution = { default_resolution_name: (800, 600), "320x240": (320, 240), "640x480": (640, 480), "1024x768": (1024, 768), "1280x960": (1280, 960), "1280x1024": (1280, 1024) } self.param_resolution = Param("resolution", default_resolution_name, lst_value=self.dct_resolution.keys()) self.param_resolution.add_notify(self.reload) default_fps_name = "30" self.dct_fps = {default_fps_name: 30, "15": 15, "7.5": 7.5} self.param_fps = Param("fps", default_fps_name, lst_value=self.dct_fps.keys()) self.param_fps.add_notify(self.reload) def open(self): try: shape = self.dct_resolution[self.param_resolution.get()] fps = self.dct_fps[self.param_fps.get()] # TODO check argument video capture self.video = cv2.VideoCapture(self.own_config.no) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, shape[0]) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, shape[1]) self.video.set(cv2.cv.CV_CAP_PROP_FPS, fps) except BaseException as e: log.printerror_stacktrace( logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return MediaStreaming.open(self) def next(self): run, image = self.video.read() if not run: raise StopIteration return image def close(self): MediaStreaming.close(self) if self.video: self.video.release() self._is_opened = False return True
class PygameCam(MediaStreaming): """Return images from the webcam.""" def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(PygameCam, self).__init__() self.media_name = config.name self.run = True self.video = None self.thread_image = None pygame.init() pygame.camera.init() self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.cam = None self._is_opened = True self.image = None def _create_params(self): default_resolution_name = "800x600" self.dct_resolution = { default_resolution_name: (800, 600), "320x240": (320, 240), "640x480": (640, 480), "1024x768": (1024, 768), "1280x960": (1280, 960), "1280x1024": (1280, 1024) } self.param_resolution = Param("resolution", default_resolution_name, lst_value=self.dct_resolution.keys()) self.param_resolution.add_notify(self.reload) default_fps_name = "30" self.dct_fps = {default_fps_name: 30, "15": 15, "7.5": 7.5} self.param_fps = Param("fps", default_fps_name, lst_value=self.dct_fps.keys()) self.param_fps.add_notify(self.reload) def open(self): try: shape = self.dct_resolution[self.param_resolution.get()] fps = self.dct_fps[self.param_fps.get()] self.video = pygame.camera.Camera(self.own_config.path, shape) self.video.start() self.thread_image = True thread.start_new_thread(self.update_image, ()) except BaseException as e: log.printerror_stacktrace( logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return MediaStreaming.open(self) def update_image(self): while self.thread_image: image_surface = self.video.get_image() image = pygame.surfarray.pixels3d(image_surface) image = np.rot90(image, 3) copy_image = np.zeros(image.shape, np.float32) copy_image = cv2.cvtColor(image, cv2.cv.CV_BGR2RGB, copy_image) self.image = copy_image def next(self): return self.image def close(self): MediaStreaming.close(self) self.thread_image = False # TODO add semaphore? self.video.stop() self._is_opened = False return True
class VideoRecorder: def __init__(self, media): self.writer = None self.media = media self.config = Configuration() self.file_name = None self.process = None # create a semaphore to protect when closing ffmpeg self.sem = Semaphore(1) def start(self, shape, path=None, fps=30, compress=0): # TODO manage multiple record # manage only one record at time if self.process: self.stop() add_format_name = False if path: # exception, if not contain /, maybe it's just a filename if "/" not in path: name = "%s%s.avi" % (self.config.get_path_save_record(), path) else: # TODO need to add extension when giving all path with # filename? name = path if os.path.isdir(path): add_format_name = True else: add_format_name = True # TODO mkdir if directory name = self.config.get_path_save_record() if add_format_name: name += "%s.avi" % time.strftime( "%Y_%m_%d_%H_%M_%S", time.gmtime()) if os.path.isfile(name): log.print_function(logger.error, "File already exist %s" % name) return False self.file_name = name logger.info("Start record on path: %s", name) # 1 is best quality, 36 is worse qscale = compress * 0.35 + 1 self.process = Popen( ['ffmpeg', '-y', '-f', 'image2pipe', '-vcodec', 'mjpeg', '-r', '24', '-i', '-', '-vcodec', 'mpeg4', '-qscale', "%s" % qscale, '-r', '24', name], stdin=PIPE) self.media.add_observer(self.add_image) return True def add_image(self, image): # take sem with blocking self.sem.acquire(True) # check if process is active after the sem if self.process is None: self.sem.release() return # convert image to rgb in image2 image2 = np.asarray(image, dtype="uint8") cv2.cvtColor(image, cv.CV_BGR2RGB, image2) # convert in PIL image img = Image.fromarray(image2, 'RGB') # Save it in ffmpeg process img.save(self.process.stdin, 'JPEG') self.sem.release() def get_file_name(self): return self.file_name if self.file_name else "" def stop(self): logger.info("Close record on path: %s", self.file_name) self.file_name = None if not self.process: return False self.media.remove_observer(self.add_image) self.sem.acquire(True) self.process.stdin.close() self.process.wait() self.process = None self.sem.release() return True
class Firewire(Media_streaming): """Return images from a Firewire device.""" def __init__(self, config): # Go into configuration/template_media for more information super(Firewire, self).__init__() self.config = Configuration() self.camera = None self.is_streaming = False self.loop_try_open_camera = False self.dct_params = {} self.call_stop = False # TODO: this is an hack that cause memory leak self.lst_garbage_camera = [] self.cam_guid = config.guid self.cam_no = config.no # the id is guid or no, writing into open_camera self.id = "" self.key_auto_param = "-auto" fps = 15 self.sleep_time = 1 / 15.0 self.media_name = config.name self.last_timestamp = -1 self.actual_timestamp = -1 self.count_not_receive = 0 self.max_not_receive = fps * 2 self.buffer_last_timestamp = False self.own_config = config self.is_rgb = config.is_rgb self.is_mono = config.is_mono self.is_format_7 = config.is_format7 self.is_yuv = config.is_yuv self.actual_image = None self.shape = (800, 600) self.count_no_image = 0 self.max_no_image = 60 if not self.try_open_camera(repeat_loop=3, sleep_time=1): return self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.update_all_property() def _create_params(self): self.dct_params = {} if not self.camera: return lst_ignore_prop = ["Trigger"] dct_prop = self.camera.get_dict_available_features() for name, value in dct_prop.items(): if name in lst_ignore_prop: continue try: if name == "White Balance": param = Param("%s%s" % (name, self.key_auto_param), False) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param param = Param("%s-red" % name, value["RV_value"], min_v=value["min"], max_v=value["max"]) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param param = Param("%s-blue" % name, value["BU_value"], min_v=value["min"], max_v=value["max"]) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param continue elif name == "Shutter" or name == "Gain": param = Param("%s%s" % (name, self.key_auto_param), False) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param param = Param(name, value["value"], min_v=value["min"], max_v=value["max"]) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param except Exception as e: log.printerror_stacktrace(logger, "%s - name: %s, value: %s" % (e, name, value)) def serialize(self): return [param.serialize() for param in self.get_properties_param()] def is_opened(self): return self.camera is not None def deserialize(self, data): if not data: return False for uno_data in data: if not uno_data: continue try: param = Param(None, None, serialize=uno_data) own_param = self.dct_params.get(param.get_name(), None) if own_param: own_param.merge(param) except Exception as e: log.printerror_stacktrace(logger, e) return False return True def initialize(self): logger.debug("initialize camera %s" % self.get_name()) if not self.camera: return False try: self.camera.initialize(reset_bus=True, mode=self.own_config.mode, framerate=self.own_config.framerate, iso_speed=self.own_config.iso_speed, operation_mode=self.own_config.operation_mode ) except: return False return True def try_open_camera(self, open_streaming=False, repeat_loop= -1, sleep_time=1): # param : # int repeat_loop - if -1, it's an infinite loop, else it's the number loop # bool open_streaming - if true, try to start the streaming of seagoat and the firewire # can be use in threading or in init self.loop_try_open_camera = True while self.loop_try_open_camera: # need to wait 1 second if camera just shutdown, else it's crash time.sleep(sleep_time) if self.call_stop: return False # check if can access to the camera if self.open_camera(): if self.initialize(): if open_streaming: if self.open(): logger.debug("Open with success %s" % self.get_name()) self.loop_try_open_camera = False return True else: logger.debug("Finish with initialize") self.loop_try_open_camera = False return True # check if need to continue the loop if not repeat_loop: self.loop_try_open_camera = False return False if repeat_loop > 0: repeat_loop -= 1 log.print_function(logger.error, "Cannot open the camera %s" % self.get_name()) def open_camera(self): logger.debug("open camera %s" % self.get_name()) try: ctx = video1394.DC1394Context() except: log.print_function(logger.error, "Libdc1394 is not supported.") return False if self.cam_guid: self.camera = ctx.createCamera(guid=self.cam_guid) self.id = "guid %s" % str(self.cam_guid) else: self.camera = ctx.createCamera(cid=self.cam_no) self.id = "no %s" % str(self.cam_no) if self.camera is not None: return True else: log.print_function(logger.warning, "No Firewire camera detected - %s." % self.id) return False def open(self): logger.debug("open firewire %s" % self.get_name()) self.call_stop = False if not self.camera: # try to open the camera # caution, can cause an infinite loop return self.try_open_camera(repeat_loop=3, open_streaming=True, sleep_time=1) self.camera.initEvent.addObserver(self.camera_init) self.camera.grabEvent.addObserver(self.camera_observer) self.camera.stopEvent.addObserver(self.camera_close) try: logger.debug("camera %s start." % self.get_name()) self.camera.start(force_rgb8=True) logger.debug("camera %s start terminated." % self.get_name()) except: self.camera.stop() self.lst_garbage_camera.append(self.camera) # something crash, restart the camera return self.try_open_camera(repeat_loop=1, open_streaming=True, sleep_time=1) return True def camera_init(self): Media_streaming.open(self) self.is_streaming = True def camera_observer(self, im, timestamp): if self.is_rgb or not self.is_mono: image = Image.fromarray(im, "RGB") image2 = np.asarray(image, dtype="uint8") # transform it to BGR cv2.cvtColor(np.copy(image), cv.CV_BGR2RGB, image2) elif self.is_mono: image2 = im self.actual_image = image2 self.last_timestamp = timestamp def camera_close(self): if not self.camera or not self.is_streaming: # we already close the camera return # anormal close, do something! logger.error("Receive events camera close %s, retry to reopen it." % (self.id)) # clean camera self.camera.grabEvent.removeObserver(self.camera_observer) self.camera.stopEvent.removeObserver(self.camera_close) # TODO: hack, always keep a reference to the camera self.lst_garbage_camera.append(self.camera) self.camera = None self.actual_image = None self.is_streaming = False # reopen the camera kwargs = {"open_streaming" : True} # TODO how using kwargs??? thread.start_new_thread(self.try_open_camera, (True,)) def get_properties_param(self): return self.dct_params.values() def update_all_property(self): # If property is auto, don't apply manual parameter lst_auto = [value[:-(len(self.key_auto_param))] for value in self.dct_params.keys() if self.key_auto_param in value] lst_active_auto = [value for value in lst_auto if self.dct_params["%s%s" % (value, self.key_auto_param)].get()] for key, value in self.dct_params.items(): contain_auto_variable = False # search active auto for active_key in lst_active_auto: if active_key in key: contain_auto_variable = True if self.key_auto_param in key: self.update_property_param(key, value.get(), update_object_param=False) if contain_auto_variable: continue # find auto key disable and cancel it if self.key_auto_param in key: continue self.update_property_param(key, value.get(), update_object_param=False) def update_property_param(self, param_name, value, update_object_param=True): if not self.camera: return False if update_object_param: self.dct_params[param_name].set(value) logger.debug("Camera %s param_name %s and value %s", self.get_name(), param_name, value) if self.key_auto_param in param_name: new_param_name = param_name[:-len(self.key_auto_param)] self.camera.set_property_auto(new_param_name, value) elif "White Balance" in param_name: if "red" in param_name: self.camera.set_whitebalance(RV_value=value) elif "blue" in param_name: self.camera.set_whitebalance(BU_value=value) else: log.print_function(logger.error, "Can define the right color %s" % param_name) return False else: self.camera.set_property(param_name, value) return True def next(self): if not self.camera or not self.is_streaming: return None diff_time = self.last_timestamp - self.actual_timestamp # logger.debug("actual time %s, last time %s, diff %s" % (self.actual_timestamp, self.last_timestamp, diff_time)) self.actual_timestamp = self.last_timestamp if self.last_timestamp == -1: if not self.buffer_last_timestamp: self.buffer_last_timestamp = True return None log.print_function(logger.warning, "No image receive from %s" % (self.get_name())) self.count_no_image += 1 if self.count_no_image > self.max_no_image: self.count_no_image = 0 self.camera_close() return None if not diff_time: self.count_not_receive += 1 if self.count_not_receive >= self.max_not_receive: # logger.error("Didn't receive since %d images. Restart the camera %s??" % (self.count_not_receive, self.id)) logger.error("Didn't receive since %d images on camera %s" % (self.count_not_receive, self.get_name())) self.actual_timestamp = self.last_timestamp = -1 self.count_not_receive = 0 # ignore if only missing one image if not self.buffer_last_timestamp: self.buffer_last_timestamp = True return self.actual_image else: logger.warning("Receive no more image from %s, timestamp %d" % (self.get_name(), self.actual_timestamp)) return None # reinitilize all protection self.buffer_last_timestamp = False self.count_no_image = 0 self.count_not_receive = 0 return self.actual_image def close(self): # Only the manager can call this close or the reload on media.py Media_streaming.close(self) self.call_stop = True self.loop_try_open_camera = False self.is_streaming = False if self.camera: self.camera.stop() self.camera.initEvent.removeObserver(self.camera_init) self.camera.grabEvent.removeObserver(self.camera_observer) self.camera.stopEvent.removeObserver(self.camera_close) # TODO: hack, always keep a reference to the camera self.lst_garbage_camera.append(self.camera) self.camera = None return True else: logger.warning("Camera %s already close." % self.get_name()) return False
class ImageGenerator(MediaStreaming): """Return a generate image.""" def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(ImageGenerator, self).__init__() self.media_name = config.name self.run = True self._is_opened = True self._create_params() self.deserialize(self.config.read_media(self.get_name())) def _create_params(self): default_width = 800 self.param_width = Param("width", default_width, min_v=1, max_v=1200) self.param_width.add_group("Resolution") self.param_width.set_description("Change width resolution.") default_height = 600 self.param_height = Param("height", default_height, min_v=1, max_v=1200) self.param_height.add_group("Resolution") self.param_height.set_description("Change height resolution.") default_fps = 30 self.param_fps = Param("fps", default_fps, min_v=1, max_v=100) self.param_fps.set_description("Change frame per second.") self.param_color_r = Param("color_r", 0, min_v=0, max_v=255) self.param_color_r.add_group("Color") self.param_color_r.set_description("Change red color.") self.param_color_g = Param("color_g", 0, min_v=0, max_v=255) self.param_color_g.add_group("Color") self.param_color_g.set_description("Change green color.") self.param_color_b = Param("color_b", 0, min_v=0, max_v=255) self.param_color_b.add_group("Color") self.param_color_b.set_description("Change blue color.") self.param_auto_color = Param("auto-change-color", False) self.param_auto_color.set_description( "Change the color automatically.") self.param_auto_color.add_group("Color") self.param_random_green = Param("pooling_green_random", False) self.param_random_green.set_description( "Active pooling update of green color with random value.") self.param_random_green.add_notify(self._active_green_pooling) self.param_random_green.add_group("Color") self.param_transpose_r_color = Param("Transpose red color", None) self.param_transpose_r_color.set_description( "Copy the red color on others color.") self.param_transpose_r_color.add_notify(self._transpose_red_color) self.param_transpose_r_color.add_group("Color") self.param_freeze = Param("freeze", False) self.param_freeze.set_description("Freeze the stream.") def next(self): if self.param_freeze.get(): return width = self.param_width.get() height = self.param_height.get() color_r = self.param_color_r.get() color_g = self.param_color_g.get() color_b = self.param_color_b.get() if self.param_auto_color.get(): color_r += 1 if color_r > 255: color_r = 0 color_g += 2 if color_g > 255: color_g = 0 color_b += 3 if color_b > 255: color_b = 0 self.param_color_r.set(color_r) self.param_color_r.set_lock(True) self.param_color_g.set(color_g) self.param_color_g.set_lock(True) self.param_color_b.set(color_b) self.param_color_b.set_lock(True) else: self.param_color_r.set_lock(False) self.param_color_g.set_lock(False) self.param_color_b.set_lock(False) image = np.zeros((height, width, 3), dtype=np.uint8) image[:, :, 0] += color_b image[:, :, 1] += color_g image[:, :, 2] += color_r return image def _transpose_red_color(self, param): color_r = self.param_color_r.get() self.param_color_g.set(color_r) self.param_color_b.set(color_r) def _active_green_pooling(self, param): if param.get(): self.param_color_g.start_pooling(self._pool_random_green) else: self.param_color_g.stop_pooling() def _pool_random_green(self, param): return randrange(255)
class Video_recorder: def __init__(self, media): self.writer = None self.media = media self.config = Configuration() self.file_name = None def start(self, shape, path=None, fps=30): # TODO manage multiple record # manage only one record at time if self.writer: self.stop() add_format_name = False if path: # exception, if not contain /, maybe it's just a filename if "/" not in path: name = "%s%s.avi" % (self.config.get_path_save_record(), path) else: # TODO need to add extension when giving all path with filename? name = path if os.path.isdir(path): add_format_name = True else: add_format_name = True # TODO mkdir if directory name = self.config.get_path_save_record() if add_format_name: name += "%s.avi" % time.strftime("%Y_%m_%d_%H_%M_%S", time.gmtime()) if os.path.isfile(name): log.print_function(logger.error, "File already exist %s" % name) return False self.file_name = name logger.info("Start record on path: %s", name) fps = 8 # fourcc = cv.CV_FOURCC('D','I','V','X') # fourcc = cv.CV_FOURCC('F', 'L', 'V', '1') # fourcc = cv.CV_FOURCC('V', 'P', '8', '0') # not work # fourcc = cv.CV_FOURCC('M', 'J', 'P', 'G') # fourcc = cv.CV_FOURCC('D', 'I', 'B', ' ') # Uncompressed RGB, 24 or 32 bit - not working linux fourcc = cv.CV_FOURCC('I', 'Y', 'U', 'V') # Uncompressed YUV, 4:2:0 chroma subsampled , same of 'I420' self.writer = cv2.VideoWriter(filename=name, fourcc=fourcc, fps=fps, frameSize=shape, isColor=1) self.writer.open(name, fourcc, fps, shape, 1) self.media.add_observer(self.writer.write) return True def get_file_name(self): if not self.file_name: return "" return self.file_name def stop(self): logger.info("Close record on path: %s", self.file_name) self.file_name = None if not self.writer: return False self.media.remove_observer(self.writer.write) del self.writer self.writer = None return True
class Webcam(Media_streaming): """Return images from the webcam.""" def __init__(self, config): # Go into configuration/template_media for more information self.config = Configuration() self.own_config = config super(Webcam, self).__init__() self.media_name = config.name self.run = True self.video = None video = cv2.VideoCapture(config.no) if video.isOpened(): self.isOpened = True video.release() self._create_params() self.deserialize(self.config.read_media(self.get_name())) def _create_params(self): self.dct_params = {} default_resolution_name = "800x600" self.dct_resolution = {default_resolution_name:(800, 600), "320x240":(320, 240), "640x480":(640, 480), "1024x768":(1024, 768), "1280x960":(1280, 960)} param = Param("resolution", default_resolution_name, lst_value=self.dct_resolution.keys()) param.add_notify_reset(self.reset_property_param) self.dct_params["resolution"] = param default_fps_name = "30" self.dct_fps = {default_fps_name:30, "15":15, "7.5":7.5} param = Param("fps", default_fps_name, lst_value=self.dct_fps.keys()) param.add_notify_reset(self.reset_property_param) self.dct_params["fps"] = param def serialize(self): return {"resolution":self.dct_params.get("resolution").get(), "fps":self.dct_params.get("fps").get()} def deserialize(self, data): if not data: return False if type(data) is not dict: log.print_function(logger.error, "Wrong format data, suppose to be dict into camera %s" % self.get_name()) return False res = data.get("resolution", None) if res: self.dct_params.get("resolution").set(res) res = data.get("fps", None) if res: self.dct_params.get("fps").set(res) return True def open(self): try: shape = self.dct_resolution[self.dct_params.get("resolution").get()] fps = self.dct_fps[self.dct_params.get("fps").get()] self.video = cv2.VideoCapture(self.own_config.no) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, shape[0]) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, shape[1]) self.video.set(cv2.cv.CV_CAP_PROP_FPS, fps) except Exception as e: log.printerror_stacktrace(logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return Media_streaming.open(self) def next(self): run, image = self.video.read() if run == False: raise StopIteration return image def close(self): Media_streaming.close(self) self.video.release() self.isOpened = False return True def get_properties_param(self): return self.dct_params.values() def update_property_param(self, param_name, value): param = self.dct_params.get(param_name, None) if not param: return False param_value = param.get() if value == param_value: return True param.set(value) self.reload() return True def reset_property_param(self, param_name, value): self.reload() return True
class Firewire(MediaStreaming): """Return images from a Firewire device.""" def __init__(self, config): # Go into configuration/template_media for more information super(Firewire, self).__init__() self.config = Configuration() self.camera = None self.is_streaming = False self.loop_try_open_camera = False self.call_stop = False self.sem_closed = threading.Semaphore() self.cam_guid = config.guid self.cam_no = config.no # the id is guid or no, writing into open_camera self.id = "" self.key_auto_param = "-auto" self.reference_param = {"power": self._power, "transmission": self._transmission} fps = 15 self.sleep_time = 1 / 15.0 self.media_name = config.name self.last_timestamp = -1 self.actual_timestamp = -1 self.count_not_receive = 0 self.max_not_receive = fps * 2 self.buffer_last_timestamp = False self.own_config = config self.is_rgb = config.is_rgb self.is_mono = config.is_mono self.is_format_7 = config.is_format7 self.is_yuv = config.is_yuv self.actual_image = None self.shape = (800, 600) self.count_no_image = 0 self.max_no_image = 120 self.lst_param_shutter = [] self.lst_param_whitebalance = [] if not self.try_open_camera(repeat_loop=3, sleep_time=1): return self._create_params() self.deserialize(self.config.read_media(self.get_name())) self.update_all_property() def is_opened(self): return self.camera is not None def initialize(self): logger.debug("initialize camera %s" % self.get_name()) if not self.camera: return False try: init = self.camera.initialize init(reset_bus=True, mode=self.own_config.mode, framerate=self.own_config.framerate, iso_speed=self.own_config.iso_speed, operation_mode=self.own_config.operation_mode) except: return False return True def try_open_camera( self, open_streaming=False, repeat_loop=-1, sleep_time=1): # param : # int repeat_loop - if -1, it's an infinite loop, \ # else it's the number loop # bool open_streaming - if true, try to start the streaming \ # of seagoat and the firewire # can be use in threading or in init self.loop_try_open_camera = True while self.loop_try_open_camera: # need to wait 1 second if camera just shutdown, else it's crash time.sleep(sleep_time) if self.call_stop: return False # check if can access to the camera if self.open_camera(): time.sleep(2) if self.initialize(): time.sleep(2) if open_streaming: time.sleep(2) if self.open(): logger.debug( "Open with success %s" % self.get_name()) self.loop_try_open_camera = False return True else: logger.debug("Finish with initialize") self.loop_try_open_camera = False return True # check if need to continue the loop if not repeat_loop: self.loop_try_open_camera = False return False if repeat_loop > 0: repeat_loop -= 1 log.print_function( logger.error, "Cannot open the camera %s" % self.get_name()) def open_camera(self): logger.debug("open camera %s" % self.get_name()) try: ctx = video1394.DC1394Context() except: log.print_function(logger.error, "Libdc1394 is not supported.") return False if self.cam_guid: self.camera = ctx.createCamera(guid=self.cam_guid) self.id = "guid %s" % str(self.cam_guid) else: self.camera = ctx.createCamera(cid=self.cam_no) self.id = "no %s" % str(self.cam_no) if self.camera is not None: return True else: log.print_function( logger.warning, "No Firewire camera detected - %s." % self.id) return False def open(self): logger.debug("open firewire %s" % self.get_name()) self.call_stop = False if not self.camera: # try to open the camera # caution, can cause an infinite loop return self.try_open_camera(repeat_loop=3, open_streaming=True, sleep_time=1) self.camera.initEvent.addObserver(self.camera_init) self.camera.grabEvent.addObserver(self.camera_observer) # self.camera.stopEvent.addObserver(self.camera_closed) try: logger.debug("camera %s start." % self.get_name()) self.camera.start(force_rgb8=True) self.param_transmission.set(True) logger.debug("camera %s start terminated." % self.get_name()) except BaseException as e: logger.error(e) self.camera.stop() # something crash, restart the camera return self.try_open_camera(repeat_loop=1, open_streaming=True, sleep_time=1) return True def camera_init(self): MediaStreaming.open(self) self.is_streaming = True def camera_observer(self, im, timestamp): if self.is_rgb or not self.is_mono: image = Image.fromarray(im, "RGB") image2 = np.asarray(image, dtype="uint8") # transform it to BGR cv2.cvtColor(np.copy(image), cv.CV_BGR2RGB, image2) elif self.is_mono: image2 = im self.actual_image = image2 self.last_timestamp = timestamp def camera_closed(self): self.sem_closed.acquire() if not self.camera or not self.is_streaming: # we already close the camera return # anormal close, do something! logger.error( "Receive events camera close %s, retry to reopen it." % self.id) # clean camera self.camera.grabEvent.removeObserver(self.camera_observer) # self.camera.stopEvent.removeObserver(self.camera_closed) self.actual_image = None # self.camera.safe_clean(free_camera=False) self.camera = None self.is_streaming = False # reopen the camera kwargs = {"open_streaming": True} # TODO how using kwargs??? if not self.call_stop: thread.start_new_thread(self.try_open_camera, (True,)) time.sleep(2) self.sem_closed.release() def next(self): if not self.camera or not self.is_streaming: return diff_time = self.last_timestamp - self.actual_timestamp # logger.debug("actual time %s, last time %s, diff %s" % # (self.actual_timestamp, self.last_timestamp, diff_time)) self.actual_timestamp = self.last_timestamp if self.last_timestamp == -1: if not self.buffer_last_timestamp: self.buffer_last_timestamp = True return log.print_function( logger.warning, "No image receive from %s" % self.get_name()) self.count_no_image += 1 if self.count_no_image > self.max_no_image: self.count_no_image = 0 self.camera_closed() return if not diff_time: self.count_not_receive += 1 if self.count_not_receive >= self.max_not_receive: # logger.error("Didn't receive since %d images. Restart the # camera %s??" % (self.count_not_receive, self.id)) logger.error( "Didn't receive since %d images on camera %s" % (self.count_not_receive, self.get_name())) self.actual_timestamp = self.last_timestamp = -1 self.count_not_receive = 0 # ignore if only missing one image if not self.buffer_last_timestamp: self.buffer_last_timestamp = True return self.actual_image else: # logger.warning( # "Receive no more image from %s, timestamp %d" % # (self.get_name(), self.actual_timestamp)) return # reinitilize all protection self.buffer_last_timestamp = False self.count_no_image = 0 self.count_not_receive = 0 return self.actual_image def close(self): # Only the manager can call this close or the reload on media.py MediaStreaming.close(self) self.call_stop = True self.loop_try_open_camera = False self.is_streaming = False if self.camera: self.param_transmission.set(False) self.camera.stop() self.camera.initEvent.removeObserver(self.camera_init) self.camera.grabEvent.removeObserver(self.camera_observer) # self.camera.stopEvent.removeObserver(self.camera_closed) self.camera.safe_clean() self.camera = None return True else: logger.warning("Camera %s already close." % self.get_name()) return False # PARAMS def _create_params(self): if not self.camera: return group_name_color = "Color" group_name_shutter = "Shutter" lst_ignore_prop = ["Trigger"] dct_prop = self.camera.get_dict_available_features() for name, value in dct_prop.items(): if name in lst_ignore_prop: continue try: if name == "White Balance": # add auto white balance param = Param("%s%s" % (name, self.key_auto_param), False) param.add_notify(self.update_property_param) param.add_group(group_name_color) param.add_notify(self._trig_auto_whitebalance) self.add_param(param) # add specific color of white balance param = Param( "RV_value", value["RV_value"], min_v=value["min"], max_v=value["max"]) param.set_description("%s-red" % name) param.add_notify(self.update_property_param) param.add_group(group_name_color) self.lst_param_whitebalance.append(param) self.add_param(param) param = Param( "BU_value", value["BU_value"], min_v=value["min"], max_v=value["max"]) param.set_description("%s-blue" % name) param.add_notify(self.update_property_param) self.lst_param_whitebalance.append(param) param.add_group(group_name_color) self.add_param(param) continue param = Param( name, value["value"], min_v=value["min"], max_v=value["max"]) param.add_notify(self.update_property_param) self.add_param(param) if name == "Shutter": self.lst_param_shutter.append(param) param.add_group(group_name_shutter) # add auto param param = Param("%s%s" % (name, self.key_auto_param), False) param.add_notify(self._trig_auto_shutter) param.add_notify(self.update_property_param) param.add_group(group_name_shutter) self.add_param(param) except BaseException as e: log.printerror_stacktrace( logger, "%s - name: %s, value: %s" % (e, name, value)) # add operational param group_operation = "operation" self.param_power = Param("Power", True) self.param_power.add_notify(self._power) self.param_power.add_group(group_operation) self.param_transmission = Param("Transmission", False) self.param_transmission.add_notify(self._transmission) self.param_transmission.add_group(group_operation) self.sync_params() def _trig_auto(self, param, lst_param, cb): if not self.camera: return False is_active = bool(param.get()) for param in lst_param: # lock/unlock and start/stop pooling param.set_lock(is_active) if is_active: param.start_pooling(cb) else: param.stop_pooling() return True def _trig_auto_shutter(self, param): return self._trig_auto(param, self.lst_param_shutter, self._get_cam_property) def _trig_auto_whitebalance(self, param): return self._trig_auto(param, self.lst_param_whitebalance, self._get_cam_whitebalance_property) def _get_cam_property(self, param): return self.camera.get_property(param.get_name()) def _get_cam_whitebalance_property(self, param): blue, red = self.camera.get_whitebalance() if "RV" in param.get_name(): return red return blue def update_all_property(self): # If property is auto, don't apply manual parameter lst_auto = [value[:-(len(self.key_auto_param))] for value in self.get_params().keys() if self.key_auto_param in value] lst_auto = [value for value in lst_auto if self.get_params("%s%s" % (value, self.key_auto_param)).get()] for key, param in self.get_params().items(): contain_auto_variable = False # search active auto for active_key in lst_auto: if active_key in key: contain_auto_variable = True if self.key_auto_param in key: self.update_property_param(param, update_object_param=False) if contain_auto_variable: continue # find auto key disable and cancel it if self.key_auto_param in key: continue self.update_property_param(param, update_object_param=False) def update_property_param(self, param, update_object_param=True): if not self.camera or param.get_is_lock(): return False param_name = param.get_name() value = param.get() if update_object_param: param.set(value) logger.debug( "Camera %s param_name %s and value %s", self.get_name(), param_name, value) if param_name.lower() in self.reference_param.keys(): self.reference_param[param_name.lower()](param) return True if self.key_auto_param in param_name: new_param_name = param_name[:-len(self.key_auto_param)] self.camera.set_property_auto(new_param_name, value) elif "RV" in param_name: self.camera.set_whitebalance(RV_value=value) elif "BU" in param_name: self.camera.set_whitebalance(BU_value=value) else: self.camera.set_property(param_name, value) return True def _power(self, param): value = param.get() self.camera.power = int(bool(value)) def _transmission(self, param): value = param.get() self.camera.transmission = int(bool(value))