parser.add_argument('--host', type=str, default="localhost", help='Ip adress of remote server.') parser.add_argument('--port', type=int, default=8090, help='Port of remote server.') args = parser.parse_args() if args.local: global_env.set_is_local(True) from SeaGoatVision.server.core.cmdHandler import CmdHandler # Directly connected to the vision server ctr = CmdHandler() else: # Connect on remote with jsonrpc from SeaGoatVision.client.controller.json_client import JsonClient ctr = JsonClient(args.port, host=args.host) if not ctr.is_connected(): logger.critical("Vision server is not accessible. Exit now.") ctr.close() sys.exit(-1) subscriber = Subscriber(ctr, 5031, addr=args.host) if not args.local: ctr.set_subscriber(subscriber)
class JsonrpcServer(): def __init__(self, port): self.server = SimpleJSONRPCServer(('', port), logRequests=False) self.cmd_handler = CmdHandler() self.dct_observer = {} self.publisher = self.cmd_handler.get_publisher() def register(self): # register all rpc callback rf = self.server.register_function rf(self.add_image_observer, "add_image_observer") rf(self.set_image_observer, "set_image_observer") rf(self.remove_image_observer, "remove_image_observer") rf(self.get_params_media, "get_params_media") rf(self.get_param_media, "get_param_media") rf(self.get_params_filterchain, "get_params_filterchain") rf(self.get_param_filterchain, "get_param_filterchain") rf(self.cmd_handler.is_connected, "is_connected") rf(self.cmd_handler.start_filterchain_execution, "start_filterchain_execution") rf(self.cmd_handler.stop_filterchain_execution, "stop_filterchain_execution") rf(self.cmd_handler.get_fps_execution, "get_fps_execution") rf(self.cmd_handler.add_output_observer, "add_output_observer") rf(self.cmd_handler.remove_output_observer, "remove_output_observer") rf(self.cmd_handler.get_execution_list, "get_execution_list") rf(self.cmd_handler.get_execution_info, "get_execution_info") rf(self.cmd_handler.get_media_list, "get_media_list") rf(self.cmd_handler.get_default_media_name, "get_default_media_name") rf(self.cmd_handler.start_record, "start_record") rf(self.cmd_handler.stop_record, "stop_record") rf(self.cmd_handler.cmd_to_media, "cmd_to_media") rf(self.cmd_handler.get_info_media, "get_info_media") rf(self.cmd_handler.save_params_media, "save_params_media") rf(self.cmd_handler.get_filterchain_list, "get_filterchain_list") rf(self.cmd_handler.delete_filterchain, "delete_filterchain") rf(self.cmd_handler.upload_filterchain, "upload_filterchain") rf(self.cmd_handler.modify_filterchain, "modify_filterchain") rf(self.cmd_handler.reload_filter, "reload_filter") rf(self.cmd_handler.save_params, "save_params") rf(self.cmd_handler.get_filter_list, "get_filter_list") rf(self.cmd_handler.get_filterchain_info, "get_filterchain_info") rf(self.cmd_handler.update_param_media, "update_param_media") rf(self.cmd_handler.reset_param_media, "reset_param_media") rf(self.cmd_handler.set_as_default_param_media, "set_as_default_param_media") rf(self.cmd_handler.update_param, "update_param") rf(self.cmd_handler.reset_param, "reset_param") rf(self.cmd_handler.set_as_default_param, "set_as_default_param") rf(self.cmd_handler.subscribe, "subscribe") rf(self.cmd_handler.get_lst_record_historic, "get_lst_record_historic") rf(self.cmd_handler.cut_video, "cut_video") rf(self.cmd_handler.get_lst_old_record_historic, "get_lst_old_record_historic") rf(self.cmd_handler.get_count_keys, "get_count_keys") def run(self): self.server.serve_forever() def close(self): logger.info("Close jsonrpc server.") self.cmd_handler.close() self.server.shutdown() def get_params_filterchain(self, execution_name, filter_name): lst_param = self.cmd_handler.get_params_filterchain( execution_name, filter_name) return self._serialize_param(lst_param) def get_param_filterchain(self, execution_name, filter_name, param_name): param = self.cmd_handler.get_param_filterchain( execution_name, filter_name, param_name) return self._serialize_param(param) def get_params_media(self, media_name): lst_param = self.cmd_handler.get_params_media(media_name) return self._serialize_param(lst_param) def get_param_media(self, media_name, param_name): param = self.cmd_handler.get_param_media(media_name, param_name) return self._serialize_param(param) @staticmethod def _serialize_param(param_obj): if isinstance(param_obj, list): return [param.serialize() for param in param_obj] if isinstance(param_obj, dict): return {name: param.serialize() for name, param in param_obj.items()} elif isinstance(param_obj, Param): return param_obj.serialize() # # OBSERVATOR ################################ # def add_image_observer(self, execution_name, filter_name): key = keys.create_unique_exec_filter_name(execution_name, filter_name) observer = self._cb_send_image(key) if self.cmd_handler.add_image_observer(observer, execution_name, filter_name): if key not in self.dct_observer: self.dct_observer[key] = observer return True return False def set_image_observer(self, execution_name, filter_name_old, filter_name_new): old_key = keys.create_unique_exec_filter_name( execution_name, filter_name_old) new_key = keys.create_unique_exec_filter_name( execution_name, filter_name_new) observer = self.dct_observer[old_key] new_observer = self._cb_send_image(new_key) if self.cmd_handler.set_image_observer(observer, execution_name, filter_name_old, filter_name_new, new_observer=new_observer): del self.dct_observer[old_key] self.dct_observer[new_key] = new_observer return True return False def remove_image_observer(self, execution_name, filter_name): key = keys.create_unique_exec_filter_name(execution_name, filter_name) observer = self.dct_observer.get(key, None) if observer is None: logger.warning("Missing image observer : %s" % key) return self.cmd_handler.remove_image_observer(observer, execution_name, filter_name) @staticmethod def _compress_cvmat(image): compress_img = cv2.imencode( ".jpeg", image, (cv.CV_IMWRITE_JPEG_QUALITY, 95)) return compress_img[1].dumps() def _cb_send_image(self, key): def _publish_image(image): compress_cvmat = self._compress_cvmat(image) self.publisher.publish(key, compress_cvmat) return _publish_image
def __init__(self, port): self.server = SimpleJSONRPCServer(('', port), logRequests=False) self.cmd_handler = CmdHandler() self.dct_observer = {} self.publisher = self.cmd_handler.get_publisher()
type=str, default="localhost", help='Ip adress of remote server.') parser.add_argument( '--port', type=int, default=8090, help='Port of remote server.') args = parser.parse_args() if args.local: global_env.set_is_local(True) from SeaGoatVision.server.core.cmdHandler import CmdHandler # Directly connected to the vision server ctr = CmdHandler() else: # Connect on remote with jsonrpc from SeaGoatVision.client.controller.json_client import JsonClient ctr = JsonClient(args.port, host=args.host) if not ctr.is_connected(): logger.critical("Vision server is not accessible. Exit now.") ctr.close() sys.exit(-1) subscriber = Subscriber(ctr, 5031, addr=args.host) if not args.local: ctr.set_subscriber(subscriber)