class Filter(PoolParam): def __init__(self, name=None): super(Filter, self).__init__() self._output_observers = list() self.original_image = None self.name = name self.dct_global_param = {} self.dct_media_param = {} self.execution_name = None self._publisher = None self._publish_key = None # add generic param self._active_param = Param("_active_filter", True) self._active_param.set_description("Enable filter in filterchain.") self._active_param.add_group("Generic") def serialize(self, is_config=False, is_info=False): if is_info: return {"name": self.name, "doc": self.__doc__} lst_param = super(Filter, self).serialize(is_config=is_config) return { "filter_name": self.__class__.__name__, "lst_param": lst_param } def deserialize(self, value): return super(Filter, self).deserialize(value.get("lst_param")) def get_name(self): return self.name def get_code_name(self): key = "-" if key in self.name: return self.name[:self.name.rfind("-")] return self.name def set_name(self, name): self.name = name def get_is_active(self): return bool(self._active_param.get()) def destroy(self): # edit me # It's called just before to be destroyed pass def configure(self): # edit me pass def execute(self, image): # edit me return image def set_global_params(self, dct_global_param): # complete the list and point on it for key, param in self.dct_global_param.items(): if key in dct_global_param: log.print_function( logger.error, "Duplicate key on dct_global_param : %s", key) continue dct_global_param[key] = param self.dct_global_param = dct_global_param self.set_global_params_cpp(self.dct_global_param) def set_global_params_cpp(self, dct_global_param): pass def set_media_param(self, dct_media_param): self.dct_media_param = dct_media_param def set_execution_name(self, execution_name): self.execution_name = execution_name def get_media_param(self, param_name): return self.dct_media_param.get(param_name, None) def set_original_image(self, image): self.original_image = image def get_original_image(self): return self.original_image def notify_output_observers(self, data): for obs in self._output_observers: obs(data) def get_list_output_observer(self): return self._output_observers def add_output_observer(self, observer): self._output_observers.append(observer) def remove_output_observer(self, observer): self._output_observers.remove(observer) def set_publisher(self, publisher): self._publisher = publisher # create publisher key execution_name = self.execution_name filter_name = self.name key = keys.create_unique_exec_filter_name(execution_name, filter_name) self._publish_key = key self._publisher.register(key) # create callback publisher self._cb_publish = self._get_cb_publisher() def _add_notification_param(self, param): # send from publisher if not self._publisher: return data = { "execution": self.execution_name, "filter": self.name, "param": param.serialize() } json_data = json.dumps(data) self._publisher.publish(keys.get_key_filter_param(), json_data) def _get_cb_publisher(self): if not self._publisher: return return self._publisher.get_callback_publish(self._publish_key) def get_media(self, name): from resource import Resource resource = Resource() return resource.get_media(name)
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 Filter(PoolParam): def __init__(self, name=None): super(Filter, self).__init__() self._output_observers = list() self.original_image = None self.name = name self.dct_global_param = {} self.dct_media_param = {} self.execution_name = None self._publisher = None self._publish_key = None # add generic param self._active_param = Param("_active_filter", True) self._active_param.set_description("Enable filter in filterchain.") self._active_param.add_group("Generic") def serialize(self, is_config=False, is_info=False): if is_info: return {"name": self.name, "doc": self.__doc__} lst_param = super(Filter, self).serialize(is_config=is_config) return {"filter_name": self.__class__.__name__, "lst_param": lst_param} def deserialize(self, value): return super(Filter, self).deserialize(value.get("lst_param")) def get_name(self): return self.name def get_code_name(self): key = "-" if key in self.name: return self.name[:self.name.rfind("-")] return self.name def set_name(self, name): self.name = name def get_is_active(self): return bool(self._active_param.get()) def destroy(self): # edit me # It's called just before to be destroyed pass def configure(self): # edit me pass def execute(self, image): # edit me return image def set_global_params(self, dct_global_param): # complete the list and point on it for key, param in self.dct_global_param.items(): if key in dct_global_param: log.print_function(logger.error, "Duplicate key on dct_global_param : %s", key) continue dct_global_param[key] = param self.dct_global_param = dct_global_param self.set_global_params_cpp(self.dct_global_param) def set_global_params_cpp(self, dct_global_param): pass def set_media_param(self, dct_media_param): self.dct_media_param = dct_media_param def set_execution_name(self, execution_name): self.execution_name = execution_name def get_media_param(self, param_name): return self.dct_media_param.get(param_name, None) def set_original_image(self, image): self.original_image = image def get_original_image(self): return self.original_image def notify_output_observers(self, data): for obs in self._output_observers: obs(data) def get_list_output_observer(self): return self._output_observers def add_output_observer(self, observer): self._output_observers.append(observer) def remove_output_observer(self, observer): self._output_observers.remove(observer) def set_publisher(self, publisher): self._publisher = publisher # create publisher key execution_name = self.execution_name filter_name = self.name key = keys.create_unique_exec_filter_name(execution_name, filter_name) self._publish_key = key self._publisher.register(key) # create callback publisher self._cb_publish = self._get_cb_publisher() def _add_notification_param(self, param): # send from publisher if not self._publisher: return data = { "execution": self.execution_name, "filter": self.name, "param": param.serialize() } json_data = json.dumps(data) self._publisher.publish(keys.get_key_filter_param(), json_data) def _get_cb_publisher(self): if not self._publisher: return return self._publisher.get_callback_publish(self._publish_key) def get_media(self, name): from resource import Resource resource = Resource() return resource.get_media(name)
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 ExePy2(Filter): """ Python Example Test #2 Example filter to test params. Show rectangle on each detected face. """ def __init__(self): Filter.__init__(self) self.dct_color_choose = {"red": (0, 0, 255), "green": (0, 255, 0), "blue": (255, 0, 0)} self.color_rect = self.dct_color_choose["red"] self.i_text_size = 1.0 # add params self.show_output = Param("enable_output", True) self.show_output.set_description("Enable to show rectangle.") self.color_rectangle = Param("color_rectangle", "red", lst_value=self.dct_color_choose.keys()) self.color_rectangle.set_description( "Change the RGB color of the rectangle.") self.color_rectangle.add_group("rectangle") self.show_rectangle = Param("show_rectangle", True) self.show_rectangle.set_description( "Colorize a rectangle around the face.") self.show_rectangle.add_group("rectangle") self.border_rec_size = Param("border_rec_size", 3, min_v=1, max_v=9) self.border_rec_size.set_description( "Change the border size of the rectangle.") self.border_rec_size.add_group("rectangle") self.show_text = Param("enable_text", True) self.show_text.set_description("Show text upper the rectangle.") self.show_text.add_group("message") self.text_face = Param("text_face", "") self.text_face.set_description("The text to write on the rectangle.") self.text_face.add_group("message") self.text_size = Param("text_size", self.i_text_size, min_v=0.1, max_v=4.9) self.text_size.set_description("Change the text size.") self.text_size.add_group("message") self.nb_face = 1 # linux path path_frontal_face = os.path.join('/', 'usr', 'share', 'opencv', 'haarcascades', 'haarcascade_frontalface_alt.xml') self.face_detect_name = os.path.join('data', 'facedetect', path_frontal_face) self.face_cascade = cv2.CascadeClassifier() self.face_cascade.load(self.face_detect_name) def configure(self): self.color_rect = self.dct_color_choose[self.color_rectangle.get()] self.i_text_size = self.text_size.get() def execute(self, image): gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) cv2.equalizeHist(gray, gray) faces = self.face_cascade.detectMultiScale(gray, 1.1, 2, 0 | cv.CV_HAAR_SCALE_IMAGE, (30, 30)) for face in faces: self.draw_rectangle(image, face, self.color_rect, self.i_text_size) self.nb_face = 1 return image def draw_rectangle(self, image, coord, color, txt_size): x, y, w, h = coord min_y = y if min_y < 0: min_y = 0 min_face_y = min_y - 10 if min_face_y < 0: min_face_y = 0 max_y = y + h if max_y > image.shape[0]: max_y = image.shape[0] min_x = x if min_x < 0: min_x = 0 max_x = x + w if max_x > image.shape[1]: max_x = image.shape[1] if self.show_rectangle.get(): cv2.rectangle(image, (min_x, min_y), (max_x, max_y), color, thickness=self.border_rec_size.get()) if self.show_text.get(): text = "%s.%s" % (self.nb_face, self.text_face.get()) cv2.putText(image, text, (min_x, min_face_y), cv2.FONT_HERSHEY_SCRIPT_SIMPLEX, txt_size, color) # note: >> 2 == / 2 c_x = (max_x - min_x) >> 2 + min_x c_y = (max_y - min_y) >> 2 + min_y if self.show_output.get(): self.notify_output_observers( "face detect no %d : x=%d, y=%d" % (self.nb_face, c_x, c_y)) self.nb_face += 1
class Media(PoolParam): def __init__(self): super(Media, self).__init__() # TODO change sleep_time dependant of real fps desire self.fps = 30.0 self.sleep_time = 1 / self.fps self.lst_observer = [] self.thread = None self.media_name = None self.active_loop = True self.is_client_manager = False # set publisher self._publisher = None self.status = None self.set_status(MediaStatus.close) # add generic param self._rotate_param = Param('angle', 0, max_v=3, min_v=0) desc = "Rotate the picture. 0 - 90 - 180 - 270" self._rotate_param.set_description(desc) self._rotate_param.add_group("Generic") def destroy(self): self.destroy_param() def set_publisher(self, publisher): self._publisher = publisher publisher.register("media.%s" % self.media_name) self._cb_publish = self._get_cb_publisher() def set_is_client_manager(self, is_client_manager): self.is_client_manager = is_client_manager def is_media_streaming(self): # complete it into media_streaming and media_video pass def is_media_video(self): # complete it into media_streaming and media_video pass def get_type_media(self): # complete it into media_streaming and media_video # type is Video or Streaming pass def get_name(self): return self.media_name def get_status(self): return self.status def set_status(self, status): if not status in MediaStatus.lst_status: msg = "Status %s in media %s not supported." % (status, self.get_name()) logger.error(msg) self.status = MediaStatus.close if self.status != status and self._cb_publish: self.status = status self._cb_publish({"status": status}) def __iter__(self): return self def get_total_frames(self): return -1 def get_info(self): fps = int(1 / self.sleep_time) if self.thread else -1 return { "fps": fps, "nb_frame": self.get_total_frames(), "status": self.get_status() } def serialize(self, is_config=False): return super(Media, self).serialize(is_config=is_config) def deserialize(self, data): return super(Media, self).deserialize(data) def get_real_fps(self): if self.thread: return self.thread.get_fps() return -1 def open(self): # IMPORTANT, if inherit, call this at the end # the thread need to be start when device is ready logger.info("Open media %s" % self.get_name()) if self.is_client_manager: return True if self.thread: return False self.thread = ThreadMedia(self, self._cb_publish, self._rotate_param) self.thread.start() return True def next(self): # edit me in child pass def reset(self): # restore the media pass def close(self): logger.info("Close media %s" % self.get_name()) self._remove_cb_publisher() self.stop_pooling_all_param() if self.is_client_manager: return True if not self.thread: return False self.thread.stop() self.thread = None self.status = MediaStatus.close return True def initialize(self): pass def reload(self, param=None): # TODO do observer and check parameter # ignore param_name and value, it's parameter from pool_param if not self.thread: return True status = self.close() if not status: return False # TODO force re-init filterchain self.initialize() return self.open() def change_sleep_time(self, sleep_time): self.sleep_time = sleep_time def add_observer(self, observer): start_media = False if not self.lst_observer: start_media = True self.lst_observer.append(observer) if start_media: self.open() def remove_observer(self, observer): if observer in self.lst_observer: self.lst_observer.remove(observer) else: logger.warning("Observer missing into media %s" % self.get_name()) if not self.lst_observer: self.close() def notify_observer(self, image): # be sure the image is different for all observer for observer in self.lst_observer: observer(np.copy(image)) def _add_notification_param(self, param): # send from publisher if not self._publisher: return data = {"media": self.media_name, "param": param.serialize()} json_data = json.dumps(data) self._publisher.publish(keys.get_key_media_param(), json_data) def set_loop_enable(self, enable): self.active_loop = enable def _get_cb_publisher(self): if not self._publisher: return key = self.get_name() return self._publisher.get_callback_publish("media.%s" % key) def _remove_cb_publisher(self): if not self._publisher: return
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)