def __init__(self):
Filter.__init__(self)
self.circley = Param("Circley", 0, min_v=0, max_v=200)
self.circlex = Param("Circlex", 0, min_v=0, max_v=200)
self.colorr = Param("colorr", 0, min_v=0, max_v=255)
self.colorg = Param("colorg", 0, min_v=0, max_v=255)
self.colorb = Param("colorb", 255, min_v=0, max_v=255)
def __init__(self):
Filter.__init__(self)
self.area_min = Param("Area Min", 300, min_v=1, max_v=100000)
self.area_max = Param("Area Max", 35000, min_v=1, max_v=100000)
self._kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3),
(0, 0))
def __init__(self):
Filter.__init__(self)
self.kernel_width = Param("Kernel Width", 3, min_v=1, max_v=256)
self.kernel_height = Param("Kernel Height", 3, min_v=1, max_v=256)
self.anchor_x = Param("Anchor X", -1)
self.anchor_y = Param("Anchor Y", -1)
self.iterations = Param("Iteration,", 1, min_v=1)
self.configure()
def __init__(self):
Filter.__init__(self)
self.blue = Param("Blue", 20, min_v=1, max_v=256, thres_h=256)
self.green = Param("Green", 20, min_v=1, max_v=256, thres_h=256)
self.red = Param("Red", 20, min_v=1, max_v=256, thres_h=256)
self._barray = None
self._garray = None
self._rarray = None
self.configure()
def _deserialize_param(params_ser):
if type(params_ser) is dict:
value = {}
for name, param_ser in params_ser.items():
param = Param(name, None, serialize=param_ser)
value[param.get_name()] = param
return value
elif type(params_ser) is list:
return [
Param("temp", None, serialize=param_ser)
for param_ser in params_ser
]
return []
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 __init__(self):
Filter.__init__(self)
self.nb_face = 1
eye_xml = 'haarcascade_eye_tree_eyeglasses.xml'
self.eye_detect_name = os.path.join('/', 'usr', 'share', 'opencv',
'haarcascades', eye_xml)
self.face_detect_nam = os.path.join('/', 'usr', 'share', 'opencv',
'haarcascades',
'haarcascade_frontalface_alt.xml')
self.eye_cascade = cv2.CascadeClassifier()
self.face_cascade = cv2.CascadeClassifier()
self.eye_cascade.load(self.eye_detect_name)
self.face_cascade.load(self.face_detect_name)
self.show_rectangle = Param("show_rectangle", True)
# To share parameter between filter, create it with :
self.add_shared_param(Param("width", 3, min_v=1, max_v=10))
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 update_param(self, json_data):
data = json.loads(json_data)
media = data.get("media", None)
param_ser = data.get("param", None)
if not media and media != self.media_name:
return
param = Param("temp", None, serialize=param_ser)
self.update_server_param(param)
def __init__(self):
Filter.__init__(self)
self.topleftx = Param("Top Left X", 0, min_v=0, max_v=640)
self.toplefty = Param("Top Left TY", 0, min_v=0, max_v=480)
self.bottomleftx = Param("Bottom Left X", 100, min_v=0, max_v=640)
self.bottomlefty = Param("Bottom Left Y", 480, min_v=0, max_v=480)
self.toprightx = Param("Top Right X", 640, min_v=0, max_v=640)
self.toprighty = Param("Top Right Y", 0, min_v=0, max_v=480)
self.bottomrightx = Param("Bottom Right X", 540, min_v=0, max_v=640)
self.bottomrighty = Param("Bottom Right Y", 480, min_v=0, max_v=480)
self.mmat = None
self.configure()
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 __init__(self):
Filter.__init__(self)
self.case = 'test'
self.resize = False
self.strength = Param("strength", 0.0, min_v=0.0, max_v=3.0)
self.naturalness = Param("naturalness", 10, min_v=0, max_v=10)
# self.sub_lum = Param("sub_lum", 100, min_v=0, max_v=255)
# self.shift_x = Param("shift_x", 0, min_v=-800, max_v=800)
# self.shift_y = Param("shift_y", 0, min_v=-600, max_v=600)
self.show_image = Param("show_images", 1, min_v=1, max_v=10)
self.limit_image = Param("limit_image", 4, min_v=1, max_v=10)
self.debug_show = Param(
"show_debug",
"show_normal",
lst_value=[
"show_normal",
"show_sat",
"show_con"])
self.show_hdr = Param("show_hdr", False)
self.index = 0
self.images = []
self.imgs = []
self.first_time = True
def update_param(self, json_data):
data = json.loads(json_data)
execution_name = data.get("execution", None)
if not execution_name and execution_name != self.execution_name:
return
filter_name = data.get("filter", None)
if not filter_name and filter_name != self.filter_name:
return
param_ser = data.get("param", None)
if not param_ser:
return
param = Param("temp", None, serialize=param_ser)
self.update_server_param(param)
def __init__(self):
Filter.__init__(self)
self.canny1 = Param("Canny1", 50, min_v=1, max_v=256)
self.canny2 = Param("Canny2", 200, min_v=1, max_v=256)
self.rho = Param("Rho", 1, min_v=1, max_v=256)
self.theta = Param("Theta", 180, min_v=0, max_v=360)
self.threshold = Param("Threshold", 100, min_v=1, max_v=256)
self.line_size = Param("Line Size", 1000, min_v=1, max_v=2000)
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 __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 __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 __init__(self):
Filter.__init__(self)
self.kernel_erode_height = Param("Kernel Erode Height",
3,
min_v=1,
max_v=255)
self.kernel_erode_width = Param("Kernel Dilate Width",
3,
min_v=1,
max_v=255)
self.kernel_dilate_height = Param("Kernel Erode Height",
5,
min_v=1,
max_v=255)
self.kernel_dilate_width = Param("Kernel Dilate Width",
5,
min_v=1,
max_v=255)
self.sections = Param("Sections", 5, min_v=1, max_v=10)
self.min_area = Param("Minimum Area", 1000, min_v=1, max_v=65535)
self.configure()
def __init__(self):
Filter.__init__(self)
self.threshold = Param("Threshold", 100, min_v=0, max_v=255)
self.technique = Param("Technique", 0, min_v=0, max_v=2)
def py_init_param(self, name, value, min=None, max=None):
param = Param(name, value, min_v=min, max_v=max)
self.params[name] = param
setattr(self, name, param)
def py_init_global_param(self, name, value, min=None, max=None):
param = Param(name, value, min_v=min, max_v=max)
self.dct_global_param[name] = param
def __init__(self):
Filter.__init__(self)
self.kernel_height = Param("Kernel Height", 3, min_v=1, max_v=256)
self.kernel_width = Param("Kernel Width", 3, min_v=1, max_v=256)
self.sigma_x = Param("Sigma X", 3, min_v=1, max_v=256)
self.sigma_y = Param("Sigma Y", 3, min_v=1, max_v=256)
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 _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 __init__(self):
Filter.__init__(self)
self._images = []
self.nb_images = Param("Nb Images", 10, min_v=1, max_v=99)
def get_param_filterchain(self, execution_name, filter_name, param_name):
param_ser = self.rpc.get_param_filterchain(execution_name, filter_name,
param_name)
return Param("temp", None, serialize=param_ser)
def get_param_media(self, media_name, param_name):
param_ser = self.rpc.get_param_media(media_name, param_name)
return Param("temp", None, serialize=param_ser)
def __init__(self):
Filter.__init__(self)
self.threshold = Param("Threshold", 12, min_v=0, max_v=255)
def __init__(self):
Filter.__init__(self)
self.kernel_height = Param("Kernel Height", 10, min_v=1, max_v=256)
self.kernel_width = Param("Kernel Width", 10, min_v=1, max_v=256)
self.area_min = Param("Area Min", 3200, min_v=1)
self.configure()
def __init__(self):
Filter.__init__(self)
self.x1 = Param('x1', 0, max_v=65535, min_v=0)
self.y1 = Param('y1', 0, max_v=65535, min_v=0)
self.x2 = Param('x2', 100, max_v=65535, min_v=0)
self.y2 = Param('y2', 100, max_v=65535, min_v=0)
