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