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