def update_param(self, execution_name, filter_name, param_name, value): request = server_pb2.UpdateParamRequest() request.execution_name = execution_name request.filter_name = filter_name; request.param.name = param_name if type(value) is int: request.param.value_int = value if type(value) is bool: request.param.value_bool = value if type(value) is float: request.param.value_float = value if type(value) is str or type(value) is unicode: request.param.value_str = value # Make an synchronous call returnValue = None try: response = self.service.update_param(request, timeout=10000) if response: returnValue = not response.status if not returnValue: if response.HasField("message"): logger.error("update_param : %s", response.message) else: logger.error("update_param.") else: returnValue = False except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def reload_filter(self, filtre=None): """ Reload Filter. Param : filtre - if None, reload all filter, else reload filter name """ request = server_pb2.ReloadFilterRequest() if type(filtre) is list: for item in filtre: request.filterName.append(item) elif type(filtre) is str or type(filtre) is unicode: request.filterName.append(filtre) elif filtre is not None: raise Exception("filtre is wrong type : %s" % type(filtre)) # Make an synchronous call returnValue = None try: response = self.service.reload_filter(request, timeout=10000) if response: returnValue = not response.status if not returnValue: if response.HasField("message"): logger.error("reload_filter : %s", response.message) else: logger.error("reload_filter.") else: returnValue = False except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def _create_params(self): self.dct_params = {} if not self.camera: return 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": param = Param("%s%s" % (name, self.key_auto_param), False) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param param = Param("%s-red" % name, value["RV_value"], min_v=value["min"], max_v=value["max"]) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param param = Param("%s-blue" % name, value["BU_value"], min_v=value["min"], max_v=value["max"]) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param continue elif name == "Shutter" or name == "Gain": param = Param("%s%s" % (name, self.key_auto_param), False) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param param = Param(name, value["value"], min_v=value["min"], max_v=value["max"]) param.add_notify_reset(self.update_property_param) self.dct_params[param.get_name()] = param except Exception as e: log.printerror_stacktrace(logger, "%s - name: %s, value: %s" % (e, name, value))
def run(self): max_error = 100 nb_error = 0 self.socket.connect("tcp://%s:%s" % (self.addr, self.port)) # TODO bug, it's not normal to subscribe for all topic self.socket.setsockopt(zmq.SUBSCRIBE, '') # Don't exit at first error receiving while nb_error < max_error and not self.is_stopped: try: while not self.is_stopped: # try: data = self.socket.recv_pyobj() if data: self.observer(data) # except zmq.error.ZMQError: # ignore it, it's the timeout # TODO can we do something with ZMQError? # pass except zmq.error.ZMQError as e: # errno 11 is Resource temporarily unavailable if e.errno == 11: continue # Context was terminated if e.errno == 156384765: self.is_stopped = True continue log.printerror_stacktrace(logger, e) except BaseException as e: log.printerror_stacktrace(logger, e) nb_error += 1 self.socket.close()
def remove_image_observer(self, controller, request, done): logger.info("remove_image_observer request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.StatusResponse() try: observer = self.dct_observer.get(request.execution_name, None) if observer and self.manager.remove_image_observer(observer.observer, request.execution_name, request.filter_name): response.status = 0 else: response.status = 1 response.message = "This remove_image_observer can't remove observer." except Exception as e: log.printerror_stacktrace(logger, e) response.status = -1 # We're done, call the run method of the done callback done.run(response) # close the socket observer = self.dct_observer.get(request.execution_name, None) if observer: observer.close() del self.dct_observer[request.execution_name]
def stop_filterchain_execution(self, execution_name): """ Stop a filterchain on the server. Param : str - The unique execution name """ request = server_pb2.StopFilterchainExecutionRequest() request.execution_name = execution_name # Make an synchronous call returnValue = None try: response = self.service.stop_filterchain_execution(request, timeout=10000) if response: returnValue = not response.status if not returnValue: if response.HasField("message"): logger.error("stop_filterchain_execution : %s", response.message) else: logger.error("stop_filterchain_execution.") else: returnValue = False except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def _create_module(cpptimestamps, module, modname, mod): try: logger.info("Begin compile %s.", modname) if cpptimestamps.has_key(modname): # Reloaded modules are saved in the reload folder for easy cleanup mod.compile(RELOAD_DIR) else: mod.compile(BUILD_DIR) cppmodule = __import__(modname) params = {} dct_fct = {'__init__' : create_init(getattr(cppmodule, 'init_' + modname), params), 'execute' : create_execute(getattr(cppmodule, 'exec_' + modname)), 'py_init_param' : py_init_param, 'py_init_global_param' : py_init_global_param, 'set_original_image' : create_set_original_image(getattr(cppmodule, 'set_original_image_' + modname)), 'set_global_params_cpp' : create_set_global_params(getattr(cppmodule, 'set_global_params_' + modname)), '__doc__' : getattr(cppmodule, 'help_' + modname)() } if has_configure: dct_fct['configure'] = create_configure(getattr(cppmodule, 'config_' + modname)) if has_destroy: dct_fct['destroy'] = create_destroy(getattr(cppmodule, 'destroy_' + modname)) clazz = type(modname, (Filter,), dct_fct) clazz.__module_init__ = module setattr(module, modname, clazz) del clazz except Exception as e: log.printerror_stacktrace(logger, e)
def delete_filterchain(self, filterchain_name): """ deleter a filterchain Param : str - filterchain name """ request = server_pb2.DeleteFilterChainRequest() request.filterchain_name = filterchain_name # Make an synchronous call returnValue = None try: response = self.service.delete_filterchain(request, timeout=10000) if response: returnValue = not response.status if not returnValue: if response.HasField("message"): logger.error("delete_filterchain : %s", response.message) else: logger.error("delete_filterchain.") else: returnValue = False except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def remove_output_observer(self, execution_name): """ remove the output information of execution to tcp_server supported only one observer. remove observer to tcp_server """ request = server_pb2.RemoveOutputObserverRequest() request.execution_name = execution_name # Make an synchronous call returnValue = None try: response = self.service.remove_output_observer(request, timeout=10000) if response: returnValue = not response.status if not returnValue: if response.HasField("message"): logger.error("remove_output_observer : %s", response.message) else: logger.error("remove_output_observer.") else: returnValue = False except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def update_param(self, controller, request, done): logger.info("update_param request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.StatusResponse() try: value = None if request.param.HasField("value_int"): value = request.param.value_int if request.param.HasField("value_bool"): value = request.param.value_bool if request.param.HasField("value_float"): value = request.param.value_float if request.param.HasField("value_str"): value = request.param.value_str try: response.status = not(self.manager.update_param(request.execution_name, request.filter_name, request.param.name, value)) except Exception as e: response.status = 1 response.message = e except Exception as e: log.printerror_stacktrace(logger, e) response.status = -1 # We're done, call the run method of the done callback done.run(response)
def upload_filterchain(self, filterchain_name, s_file_contain): """ upload a filterchain Param : str - filterchain name str - the filterchain file """ request = server_pb2.UploadFilterChainRequest() request.filterchain_name = filterchain_name request.s_file_contain = s_file_contain # Make an synchronous call returnValue = None try: response = self.service.upload_filterchain(request, timeout=10000) if response: returnValue = not response.status if not returnValue: if response.HasField("message"): logger.error("upload_filterchain : %s", response.message) else: logger.error("upload_filterchain.") else: returnValue = False except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def start_filterchain_execution(self, execution_name, media_name, filterchain_name, file_name=None, is_client_manager=False): """ Start a filterchain on the server. Param : str - The unique execution name str - The unique media name str - The unique filterchain name """ request = server_pb2.StartFilterchainExecutionRequest() request.execution_name = execution_name request.media_name = media_name request.filterchain_name = filterchain_name if file_name: request.file_name = file_name request.is_client_manager = is_client_manager # Make an synchronous call returnValue = None try: response = self.service.start_filterchain_execution(request, timeout=10000) if response: returnValue = not response.status if not returnValue: if response.HasField("message"): logger.error("start_filterchain_execution : %s", response.message) else: logger.error("start_filterchain_execution.") else: returnValue = False except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def modify_filterchain(self, old_filterchain_name, new_filterchain_name, lst_str_filters, default_media): """ Edit or create a new filterchain Param : str - old_filterchain name str - new_filterchain name list - the list in string of filters """ request = server_pb2.ModifyFilterChainRequest() request.old_filterchain_name = old_filterchain_name request.new_filterchain_name = new_filterchain_name request.default_media = default_media for filter_name in lst_str_filters: request.lst_str_filters.add().name = filter_name # Make an synchronous call returnValue = None try: response = self.service.modify_filterchain(request, timeout=10000) if response: returnValue = not response.status if not returnValue: if response.HasField("message"): logger.error("modify_filterchain : %s", response.message) else: logger.error("modify_filterchain.") else: returnValue = False except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def __init__(self, controller, host="localhost", islocal=False): super(WinMain, self).__init__() self.host = host self.controller = controller self.dct_preview = {} self.ui = get_ui(self) self.uid_iter = 0 self.id = -1 # default maximize Qt self.showMaximized() # create dockWidgets self.winFilter = WinFilter(self.controller) self.winCamera = WinCamera(self.controller) self.winFilterList = WinFilterList(self.controller) self.winMedia = WinMedia(self.controller) self.winExecution = WinExecution(self.controller) self.winFilterChain = WinFilterChain(self.controller) self.WinMainViewer = WinMainViewer() # Add default widget self.show_win_filter(first_time=True) #self.show_win_camera(first_time=True) self.show_win_filterlist(first_time=True) self.show_win_filterchain(first_time=True) self.show_win_media(first_time=True) self.show_win_execution(first_time=True) # Signal self.winFilterList.onAddFilter.connect(self.winFilterChain.add_filter) self.ui.btnMedia.clicked.connect(self.show_win_media) self.ui.btnFilterChain.clicked.connect(self.show_win_filterchain) self.ui.btnFilterList.clicked.connect(self.show_win_filterlist) self.ui.btnExecution.clicked.connect(self.show_win_execution) self.ui.btnCamera.clicked.connect(self.show_win_camera) self.ui.btnParam.clicked.connect(self.show_win_filter) self.winExecution.onPreviewClick.connect(self.addPreview) self.winExecution.onExecutionChanged.connect(self.winFilterChain.select_filterchain) self._addToolBar() self.setCentralWidget(self.WinMainViewer.ui) # register to notify server if not islocal: self.id = self.controller.add_notify_server() self.start_pull = self.id is not None try: if self.start_pull: thread.start_new_thread(self.poll_notify_server, ()) except Exception as e: log.printerror_stacktrace(logger, e) else: self.start_pull = False
def save_params(self, controller, request, done): logger.info("save_params request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.StatusResponse() try: response.status = not(self.manager.save_params(request.execution_name)) except Exception as e: log.printerror_stacktrace(logger, e) response.status = -1 # We're done, call the run method of the done callback done.run(response)
def upload_filterchain(self, controller, request, done): logger.info("upload_filterchain request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.StatusResponse() try: response.status = int(not self.manager.upload_filterchain(request.filterchain_name, request.s_file_contain)) except Exception as e: log.printerror_stacktrace(logger, e) response.status = -1 # We're done, call the run method of the done callback done.run(response)
def get_execution_list(self, controller, request, done): logger.info("get_execution_list request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.GetExecutionResponse() try: for execution in self.manager.get_execution_list(): response.execution.append(execution) except Exception as e: log.printerror_stacktrace(logger, e) # We're done, call the run method of the done callback done.run(response)
def get_real_fps_execution(self, controller, request, done): # logger.info("get_real_fps_execution request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.GetRealFpsExecutionResponse() try: response.fps = self.manager.get_real_fps_execution(request.execution_name) except Exception as e: log.printerror_stacktrace(logger, e) response.fps = -1 # We're done, call the run method of the done callback done.run(response)
def open(self): try: shape = self.dct_resolution[self.dct_params.get("resolution").get()] fps = self.dct_fps[self.dct_params.get("fps").get()] self.video = pygame.camera.Camera(self.own_config.path, shape) self.video.start() self.thread_image = True thread.start_new_thread(self.update_image, ()) except Exception as e: log.printerror_stacktrace(logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return Media_streaming.open(self)
def get_execution_info(self, execution_name): request = server_pb2.GetExecutionInfoRequest() request.execution = execution_name # Make an synchronous call returnValue = None try: response = self.service.get_execution_info(request, timeout=10000) if response: return response except Exception as e: log.printerror_stacktrace(logger, e) return None
def get_execution_list(self): request = server_pb2.GetExecutionRequest() # Make an synchronous call returnValue = None try: response = self.service.get_execution_list(request, timeout=10000) if response: return response.execution except Exception as e: log.printerror_stacktrace(logger, e) return []
def get_execution_info(self, controller, request, done): logger.info("get_execution_info request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.GetExecutionInfoResponse() try: o_exec = self.manager.get_execution_info(request.execution) response.filterchain = o_exec.filterchain response.media = o_exec.media except Exception as e: log.printerror_stacktrace(logger, e) # We're done, call the run method of the done callback done.run(response)
def open(self): try: shape = self.dct_resolution[self.dct_params.get("resolution").get()] fps = self.dct_fps[self.dct_params.get("fps").get()] self.video = cv2.VideoCapture(self.own_config.no) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, shape[0]) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, shape[1]) self.video.set(cv2.cv.CV_CAP_PROP_FPS, fps) except Exception as e: log.printerror_stacktrace(logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return Media_streaming.open(self)
def open(self): try: shape = self.dct_resolution[self.param_resolution.get()] fps = self.dct_fps[self.param_fps.get()] self.video = pygame.camera.Camera(self.own_config.path, shape) self.video.start() self.thread_image = True thread.start_new_thread(self.update_image, ()) except BaseException as e: log.printerror_stacktrace( logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return MediaStreaming.open(self)
def reload_filter(self, controller, request, done): logger.info("reload_filter request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.StatusResponse() try: self.manager.reload_filter(request.filterName[0]) response.status = 0 except Exception as e: log.printerror_stacktrace(logger, e) response.status = -1 # We're done, call the run method of the done callback done.run(response)
def need_notify(self, controller, request, done): # logger.debug("need_notify request %s", str(request).replace("\n", " ")) # Create a reply response = server_pb2.StatusResponse() try: status = self.manager.need_notify(request.id) response.status = not(status) except Exception as e: log.printerror_stacktrace(logger, e) response.status = -1 # We're done, call the run method of the done callback done.run(response)
def is_connected(self): if not self.quiet: logger.info("Try connection") request = server_pb2.IsConnectedRequest() # Make an synchronous call response = None try: response = self.service.is_connected(request, timeout=10000) is not None if response and not self.quiet: logger.info("Connection successful") except Exception as e: log.printerror_stacktrace(logger, e) return response
def get_filter_list(self): """ Return list of filter """ request = server_pb2.GetFilterListRequest() # Make an synchronous call returnValue = None try: response = self.service.get_filter_list(request, timeout=10000) returnValue = {response.filters[i]:response.doc[i] for i in range(len(response.filters))} except Exception as e: log.printerror_stacktrace(logger, e) return returnValue
def add_notify_server(self): request = server_pb2.AddNotifyRequest() # Make an synchronous call id = None try: response = self.service.add_notify_server(request, timeout=10000) if response: id = response.id if id < 0: id = None except Exception as e: log.printerror_stacktrace(logger, e) return id
def get_info_media(self, media_name): request = server_pb2.GetInfoMediaRequest() request.media_name = media_name # Make an synchronous call dct_message = {} try: response = self.service.get_info_media(request, timeout=10000) if response: message = response.message if message: dct_message = json.loads(message) except Exception as e: log.printerror_stacktrace(logger, e) return dct_message
def get_real_fps_execution(self, execution_name): request = server_pb2.GetRealFpsExecutionRequest() request.execution_name = execution_name # Make an synchronous call try: response = self.service.get_real_fps_execution(request, timeout=10000) if not response: fps = -1 else: fps = response.fps except Exception as e: log.printerror_stacktrace(logger, e) fps = -1 return fps
def _create_module(cpptimestamps, module, modname, mod, reload_mod=None): try: logger.info("Begin compile %s.", modname) no_verbose = 3 if config.get_verbose() else 0 if modname in cpptimestamps: # Reloaded modules are saved in the reload folder for easy cleanup mod.compile(RELOAD_DIR, verbose=no_verbose) else: mod.compile(BUILD_DIR, verbose=no_verbose) if reload_mod: cppmodule = __import__(reload_mod) else: cppmodule = __import__(modname) params = {} init_attr = getattr(cppmodule, 'init_' + modname) exec_attr = getattr(cppmodule, 'exec_' + modname) dct_fct = { '__init__': create_init(init_attr, params), 'execute': create_execute(exec_attr), 'py_init_param': py_init_param, 'py_init_global_param': py_init_global_param, 'set_original_image': create_set_original_image( getattr(cppmodule, 'set_original_image_' + modname)), 'set_global_params_cpp': create_set_global_params( getattr(cppmodule, 'set_global_params_' + modname)), '__doc__': getattr(cppmodule, 'help_' + modname)() } if has_configure: dct_fct['configure'] = create_configure( getattr(cppmodule, 'config_' + modname)) if has_destroy: dct_fct['destroy'] = create_destroy( getattr(cppmodule, 'destroy_' + modname)) clazz = type(modname, (Filter, ), dct_fct) clazz.__module_init__ = module setattr(module, modname, clazz) del clazz except BaseException as e: log.printerror_stacktrace(logger, e)
def open(self): try: shape = self.dct_resolution[self.param_resolution.get()] fps = self.dct_fps[self.param_fps.get()] # TODO check argument video capture self.video = cv2.VideoCapture(self.own_config.no) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, shape[0]) self.video.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, shape[1]) self.video.set(cv2.cv.CV_CAP_PROP_FPS, fps) except BaseException as e: log.printerror_stacktrace( logger, "Open camera %s: %s" % (self.get_name(), e)) return False # call open when video is ready return MediaStreaming.open(self)
def run(p_port=None, verbose=False, config_path=None): global config config = Configuration(config_path=config_path) path = config.get_log_file_path() # choose the log file path if path: log.add_handler(path) config.set_verbose(verbose) # recheck if its locked because the last check is maybe a false lock pid = os.getpid() file_lock_path = "/tmp/SeaGoat.lock" if is_lock(file_lock_path): sys.exit(-1) file_lock = open(file_lock_path, "w") file_lock.write("%s" % pid) file_lock.close() if not p_port: port = config.get_tcp_output_config() else: port = p_port # Create and register the service server = jsonrpc_server.JsonrpcServer(port) try: server.register() except BaseException as e: log.printerror_stacktrace(logger, e) server.close() sys.exit(1) # Start the server logger.info('Serving on port %s - pid %s', port, pid) logger.info('Waiting command') try: server.run() except (KeyboardInterrupt, SystemExit): logger.info("Close SeaGoat. See you later!") except BaseException: raise finally: server.close() # force closing the file os.remove(file_lock_path)
def execute(self, image): original_image = np.copy(image) # first image observator if self.original_image_observer: self.send_image(original_image, self.original_image_observer) try: for f in self.filters: if f.get_is_active(): f.set_original_image(original_image) image = f.execute(image) lst_observer = self.image_observers.get(f.get_name(), []) if lst_observer: self.send_image(image, lst_observer) except BaseException as e: msg = "(Exec exception Filter %s) %s" % (f.get_name(), e) log.printerror_stacktrace(logger, msg, check_duplicate=True) return image
def update_image(self, image): self.light_observer.active_light() # fps actual_time = time.time() if self.last_second_fps is None: # Initiate fps self.last_second_fps = actual_time self.fps_count = 1 elif actual_time - self.last_second_fps > 1.0: self.ui.lbl_stream_fps.setText("%d" % int(self.fps_count)) # new set self.last_second_fps = actual_time self.fps_count = 1 else: self.fps_count += 1 try: self.numpy_to_qimage(image) except BaseException as e: log.printerror_stacktrace(logger, e, check_duplicate=True)
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()