class ExePy1(Filter): """ Python Example Test #1 Convert BGR color to another color. """ def __init__(self): Filter.__init__(self) self.convert_color = Param("Convert choice", 1, min_v=0, max_v=4) desc = "0 = original\n1 = BGR TO YUV\n2 = BGR TO HSV\n3 = BGR TO RGB\n\ 4 = BGR TO GRAY" self.convert_color.set_description(desc) def execute(self, image): convert_color = self.convert_color.get() if convert_color == 1: image = cv2.cvtColor(image, cv2.COLOR_BGR2YUV) elif convert_color == 2: image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) elif convert_color == 3: image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) elif convert_color == 4: image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) return image
class Blur(Filter): """Smoothes an image using the normalized box filter""" def __init__(self): Filter.__init__(self) self.kernel_width = Param("width", 3, min_v=1, max_v=10) self.kernel_height = Param("height", 3, min_v=1, max_v=10) self.kernel_height.set_description("kernel's height") self.kernel_width.set_description("kernel's width") def execute(self, image): cv2.blur(image, (self.kernel_width.get(), self.kernel_height.get()), image) return image
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 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)