Python Param.set_description方法代码示例

# 需要导入模块: from SeaGoatVision.commons.param import Param [as 别名]
# 或者: from SeaGoatVision.commons.param.Param import set_description [as 别名]
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

# 需要导入模块: from SeaGoatVision.commons.param import Param [as 别名]
# 或者: from SeaGoatVision.commons.param.Param import set_description [as 别名]
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

# 需要导入模块: from SeaGoatVision.commons.param import Param [as 别名]
# 或者: from SeaGoatVision.commons.param.Param import set_description [as 别名]
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)

#.........这里部分代码省略.........

# 需要导入模块: from SeaGoatVision.commons.param import Param [as 别名]
# 或者: from SeaGoatVision.commons.param.Param import set_description [as 别名]
    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()

# 需要导入模块: from SeaGoatVision.commons.param import Param [as 别名]
# 或者: from SeaGoatVision.commons.param.Param import set_description [as 别名]
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
#.........这里部分代码省略.........

# 需要导入模块: from SeaGoatVision.commons.param import Param [as 别名]
# 或者: from SeaGoatVision.commons.param.Param import set_description [as 别名]
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
#.........这里部分代码省略.........

# 需要导入模块: from SeaGoatVision.commons.param import Param [as 别名]
# 或者: from SeaGoatVision.commons.param.Param import set_description [as 别名]
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
#.........这里部分代码省略.........