def get_am_version_info(): am_cfg = AMConfig() logger.info("Get software version of the OpenAM instance") headers = { 'X-OpenAM-Username': '******', 'X-OpenAM-Password': os.environ['AM_ADMIN_PWD'], 'Content-Type': 'application/json', 'Accept-API-Version': 'resource=2.0, protocol=1.0' } response = post(verify=am_cfg.ssl_verify, url=am_cfg.rest_authn_url, headers=headers) rest.check_http_status(http_result=response, expected_status=200) admin_token = response.json()['tokenId'] logger.info('Get AM version') headers = { 'Content-Type': 'application/json', 'Accept-API-Version': 'resource=1.0', 'iplanetdirectorypro': admin_token } response = get(verify=am_cfg.ssl_verify, url=am_cfg.am_url + '/json/serverinfo/version', headers=headers) rest.check_http_status(http_result=response, expected_status=200) version_info = "{} (build: {}, revision: {})".format( response.json()['version'], response.json()['date'], response.json()['revision']) return version_info
def handle_unresolved_url(data, action): url = unquote(data) logger.info(u'Trying to resolve URL (%s): %s' % (action, url)) if xbmc.Player().isPlaying(): utils.show_info_notification(utils.translation(32007), 1000) else: utils.show_info_notification(utils.translation(32007)) if 'youtube.com' in url or 'youtu.be' in url: youtube_addon = xbmcaddon.Addon(id="plugin.video.youtube") if youtube_addon: if utils.get_setting('preferYoutubeAddon') == 'true' or youtube_addon.getSetting("kodion.video.quality.mpd") == "true": logger.info(u'Youtube addon have DASH enabled or is configured as preferred use it') clean_url = list(urlparse(url)) clean_url[4] = '&'.join( [x for x in clean_url[4].split('&') if not re.match(r'app=', x)]) url = urlunparse(clean_url) utils.play_url('plugin://plugin.video.youtube/uri2addon/?uri=%s' % url, action) return logger.info(u'Trying to resolve with YoutubeDL') result = resolve_with_youtube_dl(url, {'format': 'best', 'no_color': 'true', 'ignoreerrors': 'true'}, action) if result: return # Second pass with new params to fix site like reddit dash streams logger.info(u'Trying to resolve with YoutubeDL other options') result = resolve_with_youtube_dl(url, {'format': 'bestvideo+bestaudio/best', 'no_color': 'true', 'ignoreerrors': 'true'}, action) if result: return logger.error(u'Url not resolved by YoutubeDL') logger.info(u'Trying to play as basic url') utils.play_url(url, action) if url: utils.show_error_notification(utils.translation(32006))
def handler(event, context): try: logger.info(event) authlete = AuthleteSdk(api_key=os.environ['AUTHLETE_API_KEY'], api_secret=os.environ['AUTHLETE_API_SECRET']) congito_user_pool = CognitoUserPool( user_pool_id=os.environ['COGNITO_USER_POOL_ID']) access_token = get_access_token_from_header(headers=event['headers']) response_content = authlete.get_user_info(access_token=access_token) sub = congito_user_pool.get_user_sub_value( username=response_content['sub']) except ValidationError as e: return response_builder(e.status_code, {'error_message': e.message}) except AuthleteApiError as e: if e.status_code != 401: logger.error(e) return response_builder(500, {'error_message': 'Internal Server Error'}) return response_builder(e.status_code, {'error_message': e.message}) except ClientError as e: logger.error(e) return response_builder(500, {'error_message': 'Internal Server Error'}) return response_builder(200, {'sub': sub, 'name': response_content['sub']})
def start_ds_port_forward(self, instance_name='userstore', instance_nb=0): if not is_cluster_mode(): ds_pod_name = '%s-%s' % (instance_name, instance_nb) ds_local_port = eval('self.%s%s_local_port' % (instance_name, instance_nb)) command = self.helm_cmd + ' --namespace %s port-forward pod/%s %s:8080' % \ (tests_namespace(), ds_pod_name, ds_local_port) ds_popen = cmd.run_cmd_process(command) duration = 60 start_time = time.time() while time.time() - start_time < duration: soc = socket.socket() result = soc.connect_ex(("", ds_local_port)) soc.close() if result != 0: logger.warning( 'Port-forward for pod %s on port %s not ready, waiting 5s...' % (ds_pod_name, ds_local_port)) time.sleep(5) else: logger.info('Port-forward for pod %s on port %s is ready' % (ds_pod_name, ds_local_port)) return ds_popen raise Exception( 'Port-forward for pod %s on port %s not ready after %ss' % (ds_pod_name, ds_local_port, duration))
def sync(self): from lib.sync import UpdateFund from lib.sync import UpdateIndice from lib.sync import UpdatePePb #import pdb;pdb.set_trace() if not (self.ui.checkBox_fund.isChecked() or self.ui.checkBox_indice.isChecked() or self.ui.checkBox_pepb.isChecked()): logger.info('请选择要更新的内容') else: if self.ui.checkBox_fund.isChecked(): updateFund = UpdateFund() updateFund.progConn.signal.connect(self.onCountChanged) self.pool.start(updateFund) if self.ui.checkBox_indice.isChecked(): updateIndice = UpdateIndice() updateIndice.progConn.signal.connect(self.onCountChanged) self.pool.start(updateIndice) if self.ui.checkBox_pepb.isChecked(): updatePePb = UpdatePePb() updatePePb.progConn.signal.connect(self.onCountChanged) self.pool.start(updatePePb) self.ui.pushButton_run.setEnabled(False)
def handler(event, context): try: logger.info(event) if verify_supported_media_type(event['headers']) is False: return response_builder( 415, { 'error_message': "This API only support 'content-type: application/x-www-form-urlencoded' media type" }) token = parse_qs(event['body']).get('token', None) if token is None: return response_builder( 400, {'error_message': 'Missing token patameter'}) authlete = AuthleteSdk(api_key=os.environ['AUTHLETE_API_KEY'], api_secret=os.environ['AUTHLETE_API_SECRET']) result = authlete.verify_access_token(token=token[0]) except AuthleteApiError as e: if e.status_code != 400: logger.error(e) return response_builder(500, {'error_message': 'Internal Server Error'}) return response_builder(e.status_code, {'error_message': e.message}) return response_builder(200, result)
def __call__(self, param): """Callback to Show speed.""" count = param.nbatch if self.last_count > count: self.init = False self.last_count = count if self.init: if count % self.frequent == 0: speed = self.frequent * self.batch_size / (time.time() - self.tic) s = "" if param.eval_metric is not None: name, value = param.eval_metric.get() s = "Epoch[%d] Batch [%d]\tSpeed: %.2f samples/sec\tTrain-" % ( param.epoch, count, speed) for n, v in zip(name, value): s += "%s=%f,\t" % (n, v) else: s = "Iter[%d] Batch [%d]\tSpeed: %.2f samples/sec" % ( param.epoch, count, speed) logger.info(s) self.tic = time.time() else: self.init = True self.tic = time.time()
def handleTenant_Delete(*args,**kwargs): event = kwargs["sender"] accountId = event.accountId session = kwargs["session"] rdclient = ServiceContext().getRdClient() rdclient.api_version = 1 try: account = session.query(Tenant).filter(Tenant.id == accountId).one() services = account.services for svc in services: nodes = svc.nodes for node in nodes: jobs = node.jobs for job in jobs: try: rdclient.delete_job(job.jobid) except: logger.warning("delete job(%s) error, just ignore any way" % job.jobid) session.delete(job) session.delete(node) session.delete(svc) session.delete(account) session.commit() logger.info("delete account<%s>." % accountId) except NoResultFound: logger.warning("account(<%s>) has been deleted, just ignore" % accountId ) finally: del rdclient.api_version
def run(self): try: logger.info("Starting '%s' suite" % self.name) self._run() finally: logger.info("Cleaning up '%s' suite." % self.name) self.cleanup()
def check_bop_results(path, version='bop19'): """Checks if the format of BOP results is correct. :param result_filenames: Path to a file with pose estimates. :param version: Version of the results. :return: True if the format is correct, False if it is not correct. """ check_passed = True check_msg = 'OK' try: results = load_bop_results(path, version) if version == 'bop19': # Check if the time for all estimates from the same image are the same. times = {} for result in results: result_key = '{:06d}_{:06d}'.format(result['scene_id'], result['im_id']) if result_key in times: if abs(times[result_key] - result['time']) > 0.001: check_passed = False check_msg = \ 'The running time for scene {} and image {} is not the same for' \ ' all estimates.'.format(result['scene_id'], result['im_id']) logger.info(check_msg) break else: times[result_key] = result['time'] except Exception as e: check_passed = False check_msg = 'Error when loading BOP results: {}'.format(e) logger.info(check_msg) return check_passed, check_msg
def handlePackage_Activate(*args,**kwargs): event = kwargs["sender"] session = kwargs["session"] accountId = event.accountId try: account = session.query(Tenant).filter(Tenant.id == accountId).one() logger.error("<%s> account is in db , need to clean.") except NoResultFound: logger.info("<%s> is new accountid , create tenant id in db" % accountId) tenant = Tenant() tenant.id = accountId tenant.name = "TBD" tenant.state = Tenant_Sate.INIT session.add(tenant) packageName = event.packageName manager = ModelManager() svcs = manager.listsvcbypath(packageName) if svcs is None: logger.error("package(%s) has no corresponding service definition..." % pkg_path) return else: for model_svc in svcs: servcie = createRuntimeService(model_svc,tenant.id) session.add(servcie) tenant.getSM().trigger("package_activate",tenant = tenant,payload = event)
def check_http_status(http_result, expected_status, known_issue=None): """ Check HTTP status code :param http_result : request.models.Response - request response :param expected_status : int or list(int) - status codes to detect that application is deployed :param known_issue : Jira issue code (ex : OPENAM-567) - used to add a tag """ if isinstance(expected_status, list): is_success = (http_result.status_code in [int(x) for x in expected_status]) else: try: is_success = (http_result.status_code == int(expected_status)) except ValueError: is_success = False if not is_success: # if known_issue is not None: # set_known_issue(known_issue) pytest.fail( 'ERROR:\n-- http status --\nreturned %s, expected %s\n-- content --\n%s' % (http_result.status_code, expected_status, http_result.text)) else: success = 'SUCCESS:\n-- http status --\nreturned %s, expected %s' % ( http_result.status_code, expected_status) logger.info(success) content = '\n-- content --\n%s' % http_result.text logger.debug(content)
def handler(event, context): try: logger.info(event) data = json.loads(event['body']) user_id = event['pathParameters']['user_id'] if 'email' not in data: return response_builder(400, {'error_message': 'emailのパラメータが足りません'}) if users.exists_user(user_id=user_id): return response_builder(409, {'error_message': '既にそのユーザは存在しています'}) users.create( user_id=user_id, email=data['email'], ) except json.decoder.JSONDecodeError: return response_builder(400, {'error_message': 'JSONが不正です'}) except ClientError as e: logger.error(e) return response_builder(500, {'error_message': 'Internal Server Error'}) return response_builder(201)
def handleCreate_VM(*args,**kwargs): event = kwargs["sender"] session = kwargs["session"] try: account = session.query(Tenant).filter(Tenant.id == event.accountId).one() except NoResultFound,e: logger.info("miss package activate message, no handle it") return
def handler(event, context): try: logger.info(event) result = users.get_all() except ClientError as e: logger.error(e) return response_builder(500, {'error_message': 'Internal Server Error'}) return response_builder(200, result['Items'])
def handle_magnet(data): open_with = utils.get_setting('openMagnetWith') logger.info('Sharing magnet with %s' % open_with) if open_with == 'Elementum': utils.call_plugin('plugin://plugin.video.elementum/playuri?uri=' + data) elif open_with == 'Torrenter V2': utils.call_plugin('plugin://plugin.video.torrenter/?action=playSTRM&url=' + data) elif open_with == 'Quasar': utils.call_plugin('plugin://plugin.video.quasar/playuri?uri=' + data) elif open_with == 'YATP': utils.call_plugin('plugin://plugin.video.yatp/?action=play&torrent=' + data + '&file_index=dialog')
def handler(event, context): try: logger.info(event) user_id = event['pathParameters']['user_id'] users.delete(user_id=user_id) except ClientError as e: logger.error(e) return response_builder(500, {'error_message': 'Internal Server Error'}) return response_builder(204)
def print_table(table_data): """ Print a table of version metadata. :param table_data: Dictionary of data to be printed """ table = PrettyTable([table_data['TITLE'], table_data['DESCRIPTION']]) for key, value in table_data.items(): if key in ['TITLE', 'DESCRIPTION']: continue table.add_row([key, value]) logger.info(table)
def par_generate_gt(config, pair_rec, flow_depth_rendered=None): from lib.pair_matching.flow import calc_flow target_size, max_size = config.SCALES[0][0], config.SCALES[0][1] if flow_depth_rendered is None: flow_depth_rendered = cv2.imread(pair_rec["depth_rendered"], cv2.IMREAD_UNCHANGED).astype( np.float32) flow_depth_rendered /= config.dataset.DEPTH_FACTOR flow_depth_rendered, _ = resize(flow_depth_rendered, target_size, max_size) if "depth_gt_observed" in pair_rec: flow_depth_observed = cv2.imread(pair_rec["depth_gt_observed"], cv2.IMREAD_UNCHANGED).astype( np.float32) flow_depth_observed /= config.dataset.DEPTH_FACTOR else: logger.info("not using gt_observed depth in par_generate_gt") flow_depth_observed = cv2.imread(pair_rec["depth_observed"], cv2.IMREAD_UNCHANGED).astype( np.float32) flow_depth_observed /= config.dataset.DEPTH_FACTOR flow_depth_observed, _ = resize(flow_depth_observed, target_size, max_size) if "mask_gt_observed" or "mask_observed" in pair_rec: mask_observed_path = pair_rec["mask_gt_observed"] assert os.path.exists(mask_observed_path), "%s does not exist".format( pair_rec["mask_gt_observed"]) mask_observed = cv2.imread(mask_observed_path, cv2.IMREAD_UNCHANGED) mask_observed, _ = resize(mask_observed, target_size, max_size) flow_depth_observed[mask_observed != pair_rec["mask_idx"]] = 0 if config.network.PRED_FLOW: flow_i2r, visible, _ = calc_flow( flow_depth_rendered, pair_rec["pose_rendered"], pair_rec["pose_observed"], config.dataset.INTRINSIC_MATRIX, flow_depth_observed, standard_rep=config.network.STANDARD_FLOW_REP, ) flow_i2r_list = [ flow_i2r, visible, np.logical_and(visible == 0, flow_depth_rendered == 0) ] return {"flow": flow_i2r_list}
def main(): logger.info("Called with argument: {}".format(args)) ctx = [mx.gpu(int(i)) for i in args.gpus.split(",")] train_net( args, ctx, config.network.pretrained, config.network.pretrained_epoch, config.TRAIN.model_prefix, config.TRAIN.begin_epoch, config.TRAIN.end_epoch, config.TRAIN.lr, config.TRAIN.lr_step, )
def handler(event, context): try: logger.info(event) authlete = AuthleteSdk(api_key=os.environ['AUTHLETE_API_KEY'], api_secret=os.environ['AUTHLETE_API_SECRET']) configuration = authlete.get_openid_configuration() except AuthleteApiError as e: logger.error(e) return response_builder(500, {'error_message': 'Internal Server Error'}) return response_builder(200, configuration)
def get_idm_version_info(): idm_cfg = IDMConfig() logger.info("Get software version of the OpenIDM instance") headers = idm_cfg.get_admin_headers({'Content-Type': 'application/json'}) response = get(verify=idm_cfg.ssl_verify, url=idm_cfg.idm_url + '/info/version', headers=headers) rest.check_http_status(http_result=response, expected_status=200) version_info = "{} (build: {}, revision: {})".format( response.json()['productVersion'], response.json()['productBuildDate'], response.json()['productRevision']) return version_info
def handler(event, context): try: logger.info(event) user_id = event['pathParameters']['user_id'] if not users.exists_user(user_id=user_id): return response_builder(404, {'error_message': 'そのユーザは存在しません'}) result = users.get(user_id=user_id) except ClientError as e: logger.error(e) return response_builder(500, {'error_message': 'Internal Server Error'}) return response_builder(200, result['Item'])
def _get_optimizer(params, optimizer_cfg, use_hvd=False): # cfg.optimizer = dict(type='RMSprop', lr=1e-4, weight_decay=0) # cfg.optimizer = dict(type='Ranger', lr=1e-4) # , N_sma_threshhold=5, betas=(.95, 0.999)) # 4, (0.90, 0.999) optim_type_str = optimizer_cfg.pop("type") if optim_type_str.lower() in ["rangerlars", "over9000"]: # RangerLars optim_type_str = "lookahead_Ralamb" optim_split = optim_type_str.split("_") optim_type = optim_split[-1] logger.info(f"optimizer: {optim_type_str} {optim_split}") if optim_type == "Ranger": from lib.torch_utils.solver.ranger import Ranger optimizer_cls = Ranger elif optim_type == "Ralamb": from lib.torch_utils.solver.ralamb import Ralamb optimizer_cls = Ralamb elif optim_type == "RAdam": from lib.torch_utils.solver.radam import RAdam optimizer_cls = RAdam else: optimizer_cls = getattr(torch.optim, optim_type) opt_kwargs = { k: v for k, v in optimizer_cfg.items() if "lookahead" not in k } optimizer = optimizer_cls(params, **opt_kwargs) if len(optim_split) > 1 and not use_hvd: if optim_split[0].lower() == "lookahead": from lib.torch_utils.solver.lookahead import Lookahead # TODO: pass lookahead hyper-params optimizer = Lookahead( optimizer, alpha=optimizer_cfg.get("lookahead_alpha", 0.5), k=optimizer_cfg.get("lookahead_k", 6), ) # logger.info(msg(type(optimizer))) return optimizer
def save_checkpoint(self, prefix, epoch, save_optimizer_states=False): """Save current progress to checkpoint. Use mx.callback.module_checkpoint as epoch_end_callback to save during training. Parameters ---------- prefix : str The file prefix to checkpoint to epoch : int The current epoch number save_optimizer_states : bool Whether to save optimizer states for continue training """ self._symbol.save("%s-symbol.json" % prefix) param_name = "%s-%04d.params" % (prefix, epoch) self.save_params(param_name) logger.info('Saved checkpoint to "%s"', param_name) if save_optimizer_states: state_name = "%s-%04d.states" % (prefix, epoch) self.save_optimizer_states(state_name) logger.info('Saved optimizer state to "%s"', state_name)
def version(self): """ Return the product version information. :return: Dictionary """ idm_cfg = IDMConfig() logger.info("Get software version of the OpenIDM instance") headers = idm_cfg.get_admin_headers( {'Content-Type': 'application/json'}) response = get(verify=idm_cfg.ssl_verify, url=idm_cfg.idm_url + '/info/version', headers=headers) rest.check_http_status(http_result=response, expected_status=200) return { 'TITLE': self.product_type, 'DESCRIPTION': self.name, 'VERSION': response.json()['productVersion'], 'REVISION': response.json()['productRevision'], 'DATE': response.json()['productBuildDate'] }
def __call__(self, num_update): """ Call to schedule current learning rate Parameters ---------- num_update: int the maximal number of updates applied to a weight. """ # NOTE: use while rather than if (for continuing training via load_epoch) if self.warmup and num_update < self.warmup_step: return self.warmup_lr while self.cur_step_ind <= len(self.step) - 1: if num_update > self.step[self.cur_step_ind]: self.count = self.step[self.cur_step_ind] self.cur_step_ind += 1 self.base_lr *= self.factor logger.info("Update[%d]: Change learning rate to %0.5e", num_update, self.base_lr) else: return self.base_lr return self.base_lr
db_url = config.get("DB","mysql_url") engine = create_engine(db_url) self.sessionmaker = sessionmaker(bind=engine) self.session = self.sessionmaker() @register def handleCreate_VM(*args,**kwargs): event = kwargs["sender"] session = kwargs["session"] try: account = session.query(Tenant).filter(Tenant.id == event.accountId).one() except NoResultFound,e: logger.info("miss package activate message, no handle it") return logger.info("handling account[%s],create_vm[%s],stackid[%s]...." % (event.accountId,event.vmType,event.stackId)) account.getSM().trigger("create_vm",tenant = account,payload=event) @register def handlePackage_Activate(*args,**kwargs): event = kwargs["sender"] session = kwargs["session"] accountId = event.accountId try: account = session.query(Tenant).filter(Tenant.id == accountId).one() logger.error("<%s> account is in db , need to clean.") except NoResultFound: logger.info("<%s> is new accountid , create tenant id in db" % accountId) tenant = Tenant() tenant.id = accountId
def pred_eval(config, predictor, test_data, imdb_test, vis=False, ignore_cache=None, logger=None, pairdb=None): """ wrapper for calculating offline validation for faster data analysis in this example, all threshold are set by hand :param predictor: Predictor :param test_data: data iterator, must be non-shuffle :param imdb_test: image database :param vis: controls visualization :param ignore_cache: ignore the saved cache file :param logger: the logger instance :return: """ logger.info(imdb_test.result_path) logger.info("test iter size: {}".format(config.TEST.test_iter)) pose_err_file = os.path.join( imdb_test.result_path, imdb_test.name + "_pose_iter{}.pkl".format(config.TEST.test_iter)) if os.path.exists(pose_err_file) and not ignore_cache and not vis: with open(pose_err_file, "rb") as fid: if six.PY3: [all_rot_err, all_trans_err, all_poses_est, all_poses_gt] = cPickle.load(fid, encoding="latin1") else: [all_rot_err, all_trans_err, all_poses_est, all_poses_gt] = cPickle.load(fid) imdb_test.evaluate_pose(config, all_poses_est, all_poses_gt) pose_add_plots_dir = os.path.join(imdb_test.result_path, "add_plots") mkdir_p(pose_add_plots_dir) imdb_test.evaluate_pose_add(config, all_poses_est, all_poses_gt, output_dir=pose_add_plots_dir) pose_arp2d_plots_dir = os.path.join(imdb_test.result_path, "arp_2d_plots") mkdir_p(pose_arp2d_plots_dir) imdb_test.evaluate_pose_arp_2d(config, all_poses_est, all_poses_gt, output_dir=pose_arp2d_plots_dir) return assert vis or not test_data.shuffle assert config.TEST.BATCH_PAIRS == 1 if not isinstance(test_data, PrefetchingIter): test_data = PrefetchingIter(test_data) num_pairs = len(pairdb) height = 480 width = 640 data_time, net_time, post_time = 0.0, 0.0, 0.0 sum_EPE_all = 0.0 num_inst_all = 0.0 sum_EPE_viz = 0.0 num_inst_viz = 0.0 sum_EPE_vizbg = 0.0 num_inst_vizbg = 0.0 sum_PoseErr = [ np.zeros((len(imdb_test.classes) + 1, 2)) for batch_idx in range(config.TEST.test_iter) ] all_rot_err = [[[] for j in range(config.TEST.test_iter)] for batch_idx in range(len(imdb_test.classes)) ] # num_cls x test_iter all_trans_err = [[[] for j in range(config.TEST.test_iter)] for batch_idx in range(len(imdb_test.classes))] all_poses_est = [[[] for j in range(config.TEST.test_iter)] for batch_idx in range(len(imdb_test.classes))] all_poses_gt = [[[] for j in range(config.TEST.test_iter)] for batch_idx in range(len(imdb_test.classes))] num_inst = np.zeros(len(imdb_test.classes) + 1) K = config.dataset.INTRINSIC_MATRIX if (config.TEST.test_iter > 1 or config.TEST.VISUALIZE) and True: print( "************* start setup render_glumpy environment... ******************" ) if config.dataset.dataset.startswith("ModelNet"): from lib.render_glumpy.render_py_light_modelnet_multi import Render_Py_Light_ModelNet_Multi modelnet_root = config.modelnet_root texture_path = os.path.join(modelnet_root, "gray_texture.png") model_path_list = [ os.path.join(config.dataset.model_dir, "{}.obj".format(model_name)) for model_name in config.dataset.class_name ] render_machine = Render_Py_Light_ModelNet_Multi( model_path_list, texture_path, K, width, height, config.dataset.ZNEAR, config.dataset.ZFAR, brightness_ratios=[0.7], ) else: render_machine = Render_Py( config.dataset.model_dir, config.dataset.class_name, K, width, height, config.dataset.ZNEAR, config.dataset.ZFAR, ) def render(render_machine, pose, cls_idx, K=None): if config.dataset.dataset.startswith("ModelNet"): idx = 2 # generate random light_position if idx % 6 == 0: light_position = [1, 0, 1] elif idx % 6 == 1: light_position = [1, 1, 1] elif idx % 6 == 2: light_position = [0, 1, 1] elif idx % 6 == 3: light_position = [-1, 1, 1] elif idx % 6 == 4: light_position = [-1, 0, 1] elif idx % 6 == 5: light_position = [0, 0, 1] else: raise Exception("???") light_position = np.array(light_position) * 0.5 # inverse yz light_position[0] += pose[0, 3] light_position[1] -= pose[1, 3] light_position[2] -= pose[2, 3] colors = np.array([1, 1, 1]) # white light intensity = np.random.uniform(0.9, 1.1, size=(3, )) colors_randk = 0 light_intensity = colors[colors_randk] * intensity # randomly choose a render machine rm_randk = 0 # random.randint(0, len(brightness_ratios) - 1) rgb_gl, depth_gl = render_machine.render( cls_idx, pose[:3, :3], pose[:3, 3], light_position, light_intensity, brightness_k=rm_randk, r_type="mat", ) rgb_gl = rgb_gl.astype("uint8") else: rgb_gl, depth_gl = render_machine.render(cls_idx, pose[:3, :3], pose[:, 3], r_type="mat", K=K) rgb_gl = rgb_gl.astype("uint8") return rgb_gl, depth_gl print( "***************setup render_glumpy environment succeed ******************" ) if config.TEST.PRECOMPUTED_ICP: print("precomputed_ICP") config.TEST.test_iter = 1 all_rot_err = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] all_trans_err = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] all_poses_est = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] all_poses_gt = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] xy_trans_err = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] z_trans_err = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] for idx in range(len(pairdb)): pose_path = pairdb[idx]["depth_rendered"][:-10] + "-pose_icp.txt" pose_rendered_update = np.loadtxt(pose_path, skiprows=1) pose_observed = pairdb[idx]["pose_observed"] r_dist_est, t_dist_est = calc_rt_dist_m(pose_rendered_update, pose_observed) xy_dist = np.linalg.norm(pose_rendered_update[:2, -1] - pose_observed[:2, -1]) z_dist = np.linalg.norm(pose_rendered_update[-1, -1] - pose_observed[-1, -1]) print( "{}: r_dist_est: {}, t_dist_est: {}, xy_dist: {}, z_dist: {}". format(idx, r_dist_est, t_dist_est, xy_dist, z_dist)) class_id = imdb_test.classes.index(pairdb[idx]["gt_class"]) # store poses estimation and gt all_poses_est[class_id][0].append(pose_rendered_update) all_poses_gt[class_id][0].append(pairdb[idx]["pose_observed"]) all_rot_err[class_id][0].append(r_dist_est) all_trans_err[class_id][0].append(t_dist_est) xy_trans_err[class_id][0].append(xy_dist) z_trans_err[class_id][0].append(z_dist) all_rot_err = np.array(all_rot_err) all_trans_err = np.array(all_trans_err) print("rot = {} +/- {}".format(np.mean(all_rot_err[class_id][0]), np.std(all_rot_err[class_id][0]))) print("trans = {} +/- {}".format(np.mean(all_trans_err[class_id][0]), np.std(all_trans_err[class_id][0]))) num_list = all_trans_err[class_id][0] print("xyz: {:.2f} +/- {:.2f}".format( np.mean(num_list) * 100, np.std(num_list) * 100)) num_list = xy_trans_err[class_id][0] print("xy: {:.2f} +/- {:.2f}".format( np.mean(num_list) * 100, np.std(num_list) * 100)) num_list = z_trans_err[class_id][0] print("z: {:.2f} +/- {:.2f}".format( np.mean(num_list) * 100, np.std(num_list) * 100)) imdb_test.evaluate_pose(config, all_poses_est, all_poses_gt) pose_add_plots_dir = os.path.join(imdb_test.result_path, "add_plots_precomputed_ICP") mkdir_p(pose_add_plots_dir) imdb_test.evaluate_pose_add(config, all_poses_est, all_poses_gt, output_dir=pose_add_plots_dir) pose_arp2d_plots_dir = os.path.join(imdb_test.result_path, "arp_2d_plots_precomputed_ICP") mkdir_p(pose_arp2d_plots_dir) imdb_test.evaluate_pose_arp_2d(config, all_poses_est, all_poses_gt, output_dir=pose_arp2d_plots_dir) return if config.TEST.BEFORE_ICP: print("before_ICP") config.TEST.test_iter = 1 all_rot_err = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] all_trans_err = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] all_poses_est = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] all_poses_gt = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] xy_trans_err = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] z_trans_err = [[[] for j in range(1)] for batch_idx in range(len(imdb_test.classes))] for idx in range(len(pairdb)): pose_path = pairdb[idx]["depth_rendered"][:-10] + "-pose.txt" pose_rendered_update = np.loadtxt(pose_path, skiprows=1) pose_observed = pairdb[idx]["pose_observed"] r_dist_est, t_dist_est = calc_rt_dist_m(pose_rendered_update, pose_observed) xy_dist = np.linalg.norm(pose_rendered_update[:2, -1] - pose_observed[:2, -1]) z_dist = np.linalg.norm(pose_rendered_update[-1, -1] - pose_observed[-1, -1]) class_id = imdb_test.classes.index(pairdb[idx]["gt_class"]) # store poses estimation and gt all_poses_est[class_id][0].append(pose_rendered_update) all_poses_gt[class_id][0].append(pairdb[idx]["pose_observed"]) all_rot_err[class_id][0].append(r_dist_est) all_trans_err[class_id][0].append(t_dist_est) xy_trans_err[class_id][0].append(xy_dist) z_trans_err[class_id][0].append(z_dist) all_trans_err = np.array(all_trans_err) imdb_test.evaluate_pose(config, all_poses_est, all_poses_gt) pose_add_plots_dir = os.path.join(imdb_test.result_path, "add_plots_before_ICP") mkdir_p(pose_add_plots_dir) imdb_test.evaluate_pose_add(config, all_poses_est, all_poses_gt, output_dir=pose_add_plots_dir) pose_arp2d_plots_dir = os.path.join(imdb_test.result_path, "arp_2d_plots_before_ICP") mkdir_p(pose_arp2d_plots_dir) imdb_test.evaluate_pose_arp_2d(config, all_poses_est, all_poses_gt, output_dir=pose_arp2d_plots_dir) return # ------------------------------------------------------------------------------ t_start = time.time() t = time.time() for idx, data_batch in enumerate(test_data): if np.sum(pairdb[idx] ["pose_rendered"]) == -12: # NO POINT VALID IN INIT POSE print(idx) class_id = imdb_test.classes.index(pairdb[idx]["gt_class"]) for pose_iter_idx in range(config.TEST.test_iter): all_poses_est[class_id][pose_iter_idx].append( pairdb[idx]["pose_rendered"]) all_poses_gt[class_id][pose_iter_idx].append( pairdb[idx]["pose_observed"]) r_dist = 1000 t_dist = 1000 all_rot_err[class_id][pose_iter_idx].append(r_dist) all_trans_err[class_id][pose_iter_idx].append(t_dist) sum_PoseErr[pose_iter_idx][class_id, :] += np.array( [r_dist, t_dist]) sum_PoseErr[pose_iter_idx][-1, :] += np.array([r_dist, t_dist]) # post process if idx % 50 == 0: logger.info( "testing {}/{} data {:.4f}s net {:.4f}s calc_gt {:.4f}s". format( (idx + 1), num_pairs, data_time / ((idx + 1) * test_data.batch_size), net_time / ((idx + 1) * test_data.batch_size), post_time / ((idx + 1) * test_data.batch_size), )) print("in test: NO POINT_VALID IN rendered") continue data_time += time.time() - t t = time.time() pose_rendered = pairdb[idx]["pose_rendered"] if np.sum(pose_rendered) == -12: print(idx) class_id = imdb_test.classes.index(pairdb[idx]["gt_class"]) num_inst[class_id] += 1 num_inst[-1] += 1 for pose_iter_idx in range(config.TEST.test_iter): all_poses_est[class_id][pose_iter_idx].append(pose_rendered) all_poses_gt[class_id][pose_iter_idx].append( pairdb[idx]["pose_observed"]) # post process if idx % 50 == 0: logger.info( "testing {}/{} data {:.4f}s net {:.4f}s calc_gt {:.4f}s". format( (idx + 1), num_pairs, data_time / ((idx + 1) * test_data.batch_size), net_time / ((idx + 1) * test_data.batch_size), post_time / ((idx + 1) * test_data.batch_size), )) t = time.time() continue output_all = predictor.predict(data_batch) net_time += time.time() - t t = time.time() rst_iter = [] for output in output_all: cur_rst = {} cur_rst["se3"] = np.squeeze( output["se3_output"].asnumpy()).astype("float32") if not config.TEST.FAST_TEST and config.network.PRED_FLOW: cur_rst["flow"] = np.squeeze( output["flow_est_crop_output"].asnumpy().transpose( (2, 3, 1, 0))).astype("float16") else: cur_rst["flow"] = None if config.network.PRED_MASK and config.TEST.UPDATE_MASK not in [ "init", "box_rendered" ]: mask_pred = np.squeeze( output["mask_observed_pred_output"].asnumpy()).astype( "float32") cur_rst["mask_pred"] = mask_pred rst_iter.append(cur_rst) post_time += time.time() - t # sample_ratio = 1 # 0.01 for batch_idx in range(0, test_data.batch_size): # if config.TEST.VISUALIZE and not (r_dist>15 and t_dist>0.05): # continue # 3388, 5326 # calculate the flow error -------------------------------------------- t = time.time() if config.network.PRED_FLOW and not config.TEST.FAST_TEST: # evaluate optical flow flow_gt = par_generate_gt(config, pairdb[idx]) if config.network.PRED_FLOW: all_diff = calc_EPE_one_pair(rst_iter[batch_idx], flow_gt, "flow") sum_EPE_all += all_diff["epe_all"] num_inst_all += all_diff["num_all"] sum_EPE_viz += all_diff["epe_viz"] num_inst_viz += all_diff["num_viz"] sum_EPE_vizbg += all_diff["epe_vizbg"] num_inst_vizbg += all_diff["num_vizbg"] # calculate the se3 error --------------------------------------------- # evaluate se3 estimation pose_rendered = pairdb[idx]["pose_rendered"] class_id = imdb_test.classes.index(pairdb[idx]["gt_class"]) num_inst[class_id] += 1 num_inst[-1] += 1 post_time += time.time() - t # iterative refine se3 estimation -------------------------------------------------- for pose_iter_idx in range(config.TEST.test_iter): t = time.time() pose_rendered_update = RT_transform( pose_rendered, rst_iter[0]["se3"][:-3], rst_iter[0]["se3"][-3:], config.dataset.trans_means, config.dataset.trans_stds, config.network.ROT_COORD, ) # calculate error r_dist, t_dist = calc_rt_dist_m(pose_rendered_update, pairdb[idx]["pose_observed"]) # store poses estimation and gt all_poses_est[class_id][pose_iter_idx].append( pose_rendered_update) all_poses_gt[class_id][pose_iter_idx].append( pairdb[idx]["pose_observed"]) all_rot_err[class_id][pose_iter_idx].append(r_dist) all_trans_err[class_id][pose_iter_idx].append(t_dist) sum_PoseErr[pose_iter_idx][class_id, :] += np.array( [r_dist, t_dist]) sum_PoseErr[pose_iter_idx][-1, :] += np.array([r_dist, t_dist]) if config.TEST.VISUALIZE: print("idx {}, iter {}: rError: {}, tError: {}".format( idx + batch_idx, pose_iter_idx + 1, r_dist, t_dist)) post_time += time.time() - t # # if more than one iteration if pose_iter_idx < (config.TEST.test_iter - 1) or config.TEST.VISUALIZE: t = time.time() # get refined image K_path = pairdb[idx]["image_observed"][:-10] + "-K.txt" if os.path.exists(K_path): K = np.loadtxt(K_path) image_refined, depth_refined = render( render_machine, pose_rendered_update, config.dataset.class_name.index( pairdb[idx]["gt_class"]), K=K, ) image_refined = image_refined[:, :, :3] # update minibatch update_package = [{ "image_rendered": image_refined, "src_pose": pose_rendered_update }] if config.network.INPUT_DEPTH: update_package[0]["depth_rendered"] = depth_refined if config.network.INPUT_MASK: mask_rendered_refined = np.zeros(depth_refined.shape) mask_rendered_refined[depth_refined > 0.2] = 1 update_package[0][ "mask_rendered"] = mask_rendered_refined if config.network.PRED_MASK: # init, box_rendered, mask_rendered, box_observed, mask_observed if config.TEST.UPDATE_MASK == "box_rendered": input_names = [ blob_name[0] for blob_name in data_batch.provide_data[0] ] update_package[0][ "mask_observed"] = np.squeeze( data_batch.data[0][input_names.index( "mask_rendered")].asnumpy() [batch_idx]) # noqa elif config.TEST.UPDATE_MASK == "init": pass else: raise Exception( "Unknown UPDATE_MASK type: {}".format( config.network.UPDATE_MASK)) pose_rendered = pose_rendered_update data_batch = update_data_batch(config, data_batch, update_package) data_time += time.time() - t # forward and get rst if pose_iter_idx < config.TEST.test_iter - 1: t = time.time() output_all = predictor.predict(data_batch) net_time += time.time() - t t = time.time() rst_iter = [] for output in output_all: cur_rst = {} if config.network.REGRESSOR_NUM == 1: cur_rst["se3"] = np.squeeze( output["se3_output"].asnumpy()).astype( "float32") if not config.TEST.FAST_TEST and config.network.PRED_FLOW: cur_rst["flow"] = np.squeeze( output["flow_est_crop_output"].asnumpy(). transpose((2, 3, 1, 0))).astype("float16") else: cur_rst["flow"] = None if config.network.PRED_MASK and config.TEST.UPDATE_MASK not in [ "init", "box_rendered" ]: mask_pred = np.squeeze( output["mask_observed_pred_output"]. asnumpy()).astype("float32") cur_rst["mask_pred"] = mask_pred rst_iter.append(cur_rst) post_time += time.time() - t # post process if idx % 50 == 0: logger.info( "testing {}/{} data {:.4f}s net {:.4f}s calc_gt {:.4f}s". format( (idx + 1), num_pairs, data_time / ((idx + 1) * test_data.batch_size), net_time / ((idx + 1) * test_data.batch_size), post_time / ((idx + 1) * test_data.batch_size), )) t = time.time() all_rot_err = np.array(all_rot_err) all_trans_err = np.array(all_trans_err) # save inference results if not config.TEST.VISUALIZE: with open(pose_err_file, "wb") as f: logger.info("saving result cache to {}".format(pose_err_file)) cPickle.dump( [all_rot_err, all_trans_err, all_poses_est, all_poses_gt], f, protocol=2) logger.info("done") if config.network.PRED_FLOW: logger.info("evaluate flow:") logger.info("EPE all: {}".format(sum_EPE_all / max(num_inst_all, 1.0))) logger.info("EPE ignore unvisible: {}".format( sum_EPE_vizbg / max(num_inst_vizbg, 1.0))) logger.info("EPE visible: {}".format(sum_EPE_viz / max(num_inst_viz, 1.0))) logger.info("evaluate pose:") imdb_test.evaluate_pose(config, all_poses_est, all_poses_gt) # evaluate pose add pose_add_plots_dir = os.path.join(imdb_test.result_path, "add_plots") mkdir_p(pose_add_plots_dir) imdb_test.evaluate_pose_add(config, all_poses_est, all_poses_gt, output_dir=pose_add_plots_dir) pose_arp2d_plots_dir = os.path.join(imdb_test.result_path, "arp_2d_plots") mkdir_p(pose_arp2d_plots_dir) imdb_test.evaluate_pose_arp_2d(config, all_poses_est, all_poses_gt, output_dir=pose_arp2d_plots_dir) logger.info("using {} seconds in total".format(time.time() - t_start))
def evaluate_pose_arp_2d(self, config, all_poses_est, all_poses_gt, output_dir): """ evaluate average re-projection 2d error :param config: :param all_poses_est: :param all_poses_gt: :param output_dir: :param logger: :return: """ logger.info("evaluating pose average re-projection 2d error") num_iter = config.TEST.test_iter K = config.dataset.INTRINSIC_MATRIX count_all = np.zeros((self.num_classes, ), dtype=np.float32) count_correct = { k: np.zeros((self.num_classes, num_iter), dtype=np.float32) for k in ["2", "5", "10", "20"] } threshold_2 = np.zeros((self.num_classes, num_iter), dtype=np.float32) threshold_5 = np.zeros((self.num_classes, num_iter), dtype=np.float32) threshold_10 = np.zeros((self.num_classes, num_iter), dtype=np.float32) threshold_20 = np.zeros((self.num_classes, num_iter), dtype=np.float32) dx = 0.1 threshold_mean = np.tile( np.arange(0, 50, dx).astype(np.float32), (self.num_classes, num_iter, 1)) # (num_class, num_iter, num_thresh) num_thresh = threshold_mean.shape[-1] count_correct["mean"] = np.zeros( (self.num_classes, num_iter, num_thresh), dtype=np.float32) for i in range(self.num_classes): threshold_2[i, :] = 2 threshold_5[i, :] = 5 threshold_10[i, :] = 10 threshold_20[i, :] = 20 num_valid_class = 0 for cls_idx, cls_name in enumerate(self.classes): if not (all_poses_est[cls_idx][0] and all_poses_gt[cls_idx][0]): continue num_valid_class += 1 for iter_i in range(num_iter): curr_poses_gt = all_poses_gt[cls_idx][0] num = len(curr_poses_gt) curr_poses_est = all_poses_est[cls_idx][iter_i] for j in range(num): if iter_i == 0: count_all[cls_idx] += 1 RT = curr_poses_est[j] # est pose pose_gt = curr_poses_gt[j] # gt pose error_rotation = re(RT[:3, :3], pose_gt[:3, :3]) if cls_name == "eggbox" and error_rotation > 90: RT_z = np.array([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0]]) RT_sym = se3_mul(RT, RT_z) error = arp_2d(RT_sym[:3, :3], RT_sym[:, 3], pose_gt[:3, :3], pose_gt[:, 3], self._points[cls_name], K) else: error = arp_2d(RT[:3, :3], RT[:, 3], pose_gt[:3, :3], pose_gt[:, 3], self._points[cls_name], K) if error < threshold_2[cls_idx, iter_i]: count_correct["2"][cls_idx, iter_i] += 1 if error < threshold_5[cls_idx, iter_i]: count_correct["5"][cls_idx, iter_i] += 1 if error < threshold_10[cls_idx, iter_i]: count_correct["10"][cls_idx, iter_i] += 1 if error < threshold_20[cls_idx, iter_i]: count_correct["20"][cls_idx, iter_i] += 1 for thresh_i in range(num_thresh): if error < threshold_mean[cls_idx, iter_i, thresh_i]: count_correct["mean"][cls_idx, iter_i, thresh_i] += 1 import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt # store plot data plot_data = {} sum_acc_mean = np.zeros(num_iter) sum_acc_02 = np.zeros(num_iter) sum_acc_05 = np.zeros(num_iter) sum_acc_10 = np.zeros(num_iter) sum_acc_20 = np.zeros(num_iter) for cls_idx, cls_name in enumerate(self.classes): if count_all[cls_idx] == 0: continue plot_data[cls_name] = [] for iter_i in range(num_iter): logger.info("** {}, iter {} **".format(cls_name, iter_i + 1)) from scipy.integrate import simps area = simps(count_correct["mean"][cls_idx, iter_i] / float(count_all[cls_idx]), dx=dx) / (50.0) acc_mean = area * 100 sum_acc_mean[iter_i] += acc_mean acc_02 = 100 * float(count_correct["2"][cls_idx, iter_i]) / float( count_all[cls_idx]) sum_acc_02[iter_i] += acc_02 acc_05 = 100 * float(count_correct["5"][cls_idx, iter_i]) / float( count_all[cls_idx]) sum_acc_05[iter_i] += acc_05 acc_10 = 100 * float( count_correct["10"][cls_idx, iter_i]) / float( count_all[cls_idx]) sum_acc_10[iter_i] += acc_10 acc_20 = 100 * float( count_correct["20"][cls_idx, iter_i]) / float( count_all[cls_idx]) sum_acc_20[iter_i] += acc_20 fig = plt.figure() x_s = np.arange(0, 50, dx).astype(np.float32) y_s = 100 * count_correct["mean"][cls_idx, iter_i] / float( count_all[cls_idx]) plot_data[cls_name].append((x_s, y_s)) plt.plot(x_s, y_s, "-") plt.xlim(0, 50) plt.ylim(0, 100) plt.grid(True) plt.xlabel("px") plt.ylabel("correctly estimated poses in %") plt.savefig(os.path.join( output_dir, "arp_2d_{}_iter{}.png".format(cls_name, iter_i + 1)), dpi=fig.dpi) logger.info("threshold=[0, 50], area: {:.2f}".format(acc_mean)) logger.info( "threshold=2, correct poses: {}, all poses: {}, accuracy: {:.2f}" .format(count_correct["2"][cls_idx, iter_i], count_all[cls_idx], acc_02)) logger.info( "threshold=5, correct poses: {}, all poses: {}, accuracy: {:.2f}" .format(count_correct["5"][cls_idx, iter_i], count_all[cls_idx], acc_05)) logger.info( "threshold=10, correct poses: {}, all poses: {}, accuracy: {:.2f}" .format(count_correct["10"][cls_idx, iter_i], count_all[cls_idx], acc_10)) logger.info( "threshold=20, correct poses: {}, all poses: {}, accuracy: {:.2f}" .format(count_correct["20"][cls_idx, iter_i], count_all[cls_idx], acc_20)) logger.info(" ") with open(os.path.join(output_dir, "arp_2d_xys.pkl"), "wb") as f: cPickle.dump(plot_data, f, protocol=2) logger.info("=" * 30) print(" ") # overall performance of arp 2d for iter_i in range(num_iter): logger.info( "---------- arp 2d performance over {} classes -----------". format(num_valid_class)) logger.info("** iter {} **".format(iter_i + 1)) logger.info("threshold=[0, 50], area: {:.2f}".format( sum_acc_mean[iter_i] / num_valid_class)) logger.info("threshold=2, mean accuracy: {:.2f}".format( sum_acc_02[iter_i] / num_valid_class)) logger.info("threshold=5, mean accuracy: {:.2f}".format( sum_acc_05[iter_i] / num_valid_class)) logger.info("threshold=10, mean accuracy: {:.2f}".format( sum_acc_10[iter_i] / num_valid_class)) logger.info("threshold=20, mean accuracy: {:.2f}".format( sum_acc_20[iter_i] / num_valid_class)) logger.info(" ") logger.info("=" * 30)
def evaluate_pose_add(self, config, all_poses_est, all_poses_gt, output_dir): """ :param config: :param all_poses_est: :param all_poses_gt: :param output_dir: :param logger: :return: """ logger.info("evaluating pose add") eval_method = "add" num_iter = config.TEST.test_iter count_all = np.zeros((self.num_classes, ), dtype=np.float32) count_correct = { k: np.zeros((self.num_classes, num_iter), dtype=np.float32) for k in ["0.02", "0.05", "0.10"] } threshold_002 = np.zeros((self.num_classes, num_iter), dtype=np.float32) threshold_005 = np.zeros((self.num_classes, num_iter), dtype=np.float32) threshold_010 = np.zeros((self.num_classes, num_iter), dtype=np.float32) dx = 0.0001 threshold_mean = np.tile( np.arange(0, 0.1, dx).astype(np.float32), (self.num_classes, num_iter, 1)) # (num_class, num_iter, num_thresh) num_thresh = threshold_mean.shape[-1] count_correct["mean"] = np.zeros( (self.num_classes, num_iter, num_thresh), dtype=np.float32) for i, cls_name in enumerate(self.classes): threshold_002[i, :] = 0.02 * self._diameters[cls_name] threshold_005[i, :] = 0.05 * self._diameters[cls_name] threshold_010[i, :] = 0.10 * self._diameters[cls_name] threshold_mean[i, :, :] *= self._diameters[cls_name] num_valid_class = 0 for cls_idx, cls_name in enumerate(self.classes): if not (all_poses_est[cls_idx][0] and all_poses_gt[cls_idx][0]): continue num_valid_class += 1 for iter_i in range(num_iter): curr_poses_gt = all_poses_gt[cls_idx][0] num = len(curr_poses_gt) curr_poses_est = all_poses_est[cls_idx][iter_i] for j in range(num): if iter_i == 0: count_all[cls_idx] += 1 RT = curr_poses_est[j] # est pose pose_gt = curr_poses_gt[j] # gt pose if cls_name == "eggbox" or cls_name == "glue" or cls_name == "bowl" or cls_name == "cup": eval_method = "adi" error = adi(RT[:3, :3], RT[:, 3], pose_gt[:3, :3], pose_gt[:, 3], self._points[cls_name]) else: error = add(RT[:3, :3], RT[:, 3], pose_gt[:3, :3], pose_gt[:, 3], self._points[cls_name]) if error < threshold_002[cls_idx, iter_i]: count_correct["0.02"][cls_idx, iter_i] += 1 if error < threshold_005[cls_idx, iter_i]: count_correct["0.05"][cls_idx, iter_i] += 1 if error < threshold_010[cls_idx, iter_i]: count_correct["0.10"][cls_idx, iter_i] += 1 for thresh_i in range(num_thresh): if error < threshold_mean[cls_idx, iter_i, thresh_i]: count_correct["mean"][cls_idx, iter_i, thresh_i] += 1 import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt plot_data = {} sum_acc_mean = np.zeros(num_iter) sum_acc_002 = np.zeros(num_iter) sum_acc_005 = np.zeros(num_iter) sum_acc_010 = np.zeros(num_iter) for cls_idx, cls_name in enumerate(self.classes): if count_all[cls_idx] == 0: continue plot_data[cls_name] = [] for iter_i in range(num_iter): logger.info("** {}, iter {} **".format(cls_name, iter_i + 1)) from scipy.integrate import simps area = simps(count_correct["mean"][cls_idx, iter_i] / float(count_all[cls_idx]), dx=dx) / 0.1 acc_mean = area * 100 sum_acc_mean[iter_i] += acc_mean acc_002 = 100 * float( count_correct["0.02"][cls_idx, iter_i]) / float( count_all[cls_idx]) sum_acc_002[iter_i] += acc_002 acc_005 = 100 * float( count_correct["0.05"][cls_idx, iter_i]) / float( count_all[cls_idx]) sum_acc_005[iter_i] += acc_005 acc_010 = 100 * float( count_correct["0.10"][cls_idx, iter_i]) / float( count_all[cls_idx]) sum_acc_010[iter_i] += acc_010 fig = plt.figure() x_s = np.arange(0, 0.1, dx).astype(np.float32) y_s = count_correct["mean"][cls_idx, iter_i] / float( count_all[cls_idx]) plot_data[cls_name].append((x_s, y_s)) plt.plot(x_s, y_s, "-") plt.xlim(0, 0.1) plt.ylim(0, 1) plt.xlabel("Average distance threshold in meter (symmetry)") plt.ylabel("accuracy") plt.savefig(os.path.join( output_dir, "acc_thres_{}_iter{}.png".format(cls_name, iter_i + 1)), dpi=fig.dpi) logger.info( "threshold=[0.0, 0.10], area: {:.2f}".format(acc_mean)) logger.info( "threshold=0.02, correct poses: {}, all poses: {}, accuracy: {:.2f}" .format(count_correct["0.02"][cls_idx, iter_i], count_all[cls_idx], acc_002)) logger.info( "threshold=0.05, correct poses: {}, all poses: {}, accuracy: {:.2f}" .format(count_correct["0.05"][cls_idx, iter_i], count_all[cls_idx], acc_005)) logger.info( "threshold=0.10, correct poses: {}, all poses: {}, accuracy: {:.2f}" .format(count_correct["0.10"][cls_idx, iter_i], count_all[cls_idx], acc_010)) logger.info(" ") with open(os.path.join(output_dir, "{}_xys.pkl".format(eval_method)), "wb") as f: cPickle.dump(plot_data, f, protocol=2) logger.info("=" * 30) print(" ") # overall performance of add for iter_i in range(num_iter): logger.info( "---------- add performance over {} classes -----------". format(num_valid_class)) logger.info("** iter {} **".format(iter_i + 1)) logger.info("threshold=[0.0, 0.10], area: {:.2f}".format( sum_acc_mean[iter_i] / num_valid_class)) logger.info("threshold=0.02, mean accuracy: {:.2f}".format( sum_acc_002[iter_i] / num_valid_class)) logger.info("threshold=0.05, mean accuracy: {:.2f}".format( sum_acc_005[iter_i] / num_valid_class)) logger.info("threshold=0.10, mean accuracy: {:.2f}".format( sum_acc_010[iter_i] / num_valid_class)) print(" ") logger.info("=" * 30)
def evaluate_pose(self, config, all_poses_est, all_poses_gt): # evaluate and display logger.info("evaluating pose") rot_thresh_list = np.arange(1, 11, 1) trans_thresh_list = np.arange(0.01, 0.11, 0.01) num_metric = len(rot_thresh_list) num_iter = config.TEST.test_iter rot_acc = np.zeros((self.num_classes, num_iter, num_metric)) trans_acc = np.zeros((self.num_classes, num_iter, num_metric)) space_acc = np.zeros((self.num_classes, num_iter, num_metric)) num_valid_class = 0 for cls_idx, cls_name in enumerate(self.classes): if not (all_poses_est[cls_idx][0] and all_poses_gt[cls_idx][0]): continue num_valid_class += 1 for iter_i in range(num_iter): curr_poses_gt = all_poses_gt[cls_idx][0] num = len(curr_poses_gt) curr_poses_est = all_poses_est[cls_idx][iter_i] cur_rot_rst = np.zeros((num, 1)) cur_trans_rst = np.zeros((num, 1)) for j in range(num): r_dist_est, t_dist_est = calc_rt_dist_m( curr_poses_est[j], curr_poses_gt[j]) if cls_name == "eggbox" and r_dist_est > 90: RT_z = np.array([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0]]) curr_pose_est_sym = se3_mul(curr_poses_est[j], RT_z) r_dist_est, t_dist_est = calc_rt_dist_m( curr_pose_est_sym, curr_poses_gt[j]) cur_rot_rst[j, 0] = r_dist_est cur_trans_rst[j, 0] = t_dist_est for thresh_idx in range(num_metric): rot_acc[cls_idx, iter_i, thresh_idx] = np.mean( cur_rot_rst < rot_thresh_list[thresh_idx]) trans_acc[cls_idx, iter_i, thresh_idx] = np.mean( cur_trans_rst < trans_thresh_list[thresh_idx]) space_acc[cls_idx, iter_i, thresh_idx] = np.mean( np.logical_and( cur_rot_rst < rot_thresh_list[thresh_idx], cur_trans_rst < trans_thresh_list[thresh_idx])) show_list = [1, 4, 9] logger.info("------------ {} -----------".format(cls_name)) logger.info("{:>24}: {:>7}, {:>7}, {:>7}".format( "[rot_thresh, trans_thresh", "RotAcc", "TraAcc", "SpcAcc")) for iter_i in range(num_iter): logger.info("** iter {} **".format(iter_i + 1)) logger.info("{:<16}{:>8}: {:>7.2f}, {:>7.2f}, {:>7.2f}".format( "average_accuracy", "[{:>2}, {:>4}]".format(-1, -1), np.mean(rot_acc[cls_idx, iter_i, :]) * 100, np.mean(trans_acc[cls_idx, iter_i, :]) * 100, np.mean(space_acc[cls_idx, iter_i, :]) * 100, )) for i, show_idx in enumerate(show_list): logger.info( "{:>16}{:>8}: {:>7.2f}, {:>7.2f}, {:>7.2f}".format( "average_accuracy", "[{:>2}, {:>4}]".format( rot_thresh_list[show_idx], trans_thresh_list[show_idx]), rot_acc[cls_idx, iter_i, show_idx] * 100, trans_acc[cls_idx, iter_i, show_idx] * 100, space_acc[cls_idx, iter_i, show_idx] * 100, )) print(" ") # overall performance for iter_i in range(num_iter): show_list = [1, 4, 9] logger.info( "---------- performance over {} classes -----------".format( num_valid_class)) logger.info("** iter {} **".format(iter_i + 1)) logger.info("{:>24}: {:>7}, {:>7}, {:>7}".format( "[rot_thresh, trans_thresh", "RotAcc", "TraAcc", "SpcAcc")) logger.info("{:<16}{:>8}: {:>7.2f}, {:>7.2f}, {:>7.2f}".format( "average_accuracy", "[{:>2}, {:>4}]".format(-1, -1), np.sum(rot_acc[:, iter_i, :]) / (num_valid_class * num_metric) * 100, np.sum(trans_acc[:, iter_i, :]) / (num_valid_class * num_metric) * 100, np.sum(space_acc[:, iter_i, :]) / (num_valid_class * num_metric) * 100, )) for i, show_idx in enumerate(show_list): logger.info("{:>16}{:>8}: {:>7.2f}, {:>7.2f}, {:>7.2f}".format( "average_accuracy", "[{:>2}, {:>4}]".format(rot_thresh_list[show_idx], trans_thresh_list[show_idx]), np.sum(rot_acc[:, iter_i, show_idx]) / num_valid_class * 100, np.sum(trans_acc[:, iter_i, show_idx]) / num_valid_class * 100, np.sum(space_acc[:, iter_i, show_idx]) / num_valid_class * 100, )) print(" ")
def test(): client = WindmillTestClient(__name__) for klass in suite_classes: suite = klass(client) suite.run() logger.info("Finished with test run")
def resolve_with_youtube_dl(url, parameters, action): youtube_dl_resolver = YoutubeDL(parameters) youtube_dl_resolver.add_default_info_extractors() try: result = youtube_dl_resolver.extract_info(url, download=False) if result is None: result = {} except Exception as e: logger.error(u'Error with YoutubeDL: %s' % e) result = {} logger.info(u'YoutubeDL full result: %s' % result) if 'entries' in result: logger.info(u'Playlist resolved by YoutubeDL: %s items' % len(result['entries'])) item_list = [] for entry in result['entries']: if entry is not None and 'url' in entry: item_list.append(entry) logger.info(u'Media found: %s' % entry['url']) if len(item_list) > 0: utils.play_items(item_list, action) return True else: logger.info(u'No playable urls in the playlist') if 'url' in result: logger.info(u'Url resolved by YoutubeDL: %s' % result['url']) utils.play_url(result['url'], action, result) return True if 'requested_formats' in result: if have_adaptive_plugin: logger.info(u'Adaptive plugin enabled looking for dash content') for entry in result['requested_formats']: if 'container' in entry and 'manifest_url' in entry: if 'dash' in entry['container']: logger.info(u'Url resolved by YoutubeDL: %s' % entry['manifest_url']) utils.play_url(entry['manifest_url'], action, result, True) return True for entry in result['requested_formats']: if 'protocol' in entry and 'manifest_url' in entry: if 'm3u8' in entry['protocol']: logger.info(u'Url resolved by YoutubeDL: %s' % entry['manifest_url']) utils.play_url(entry['manifest_url'], action, result) return True return False
def handle_unresolved_url(data, action): url = unquote(data) logger.info(u'Trying to resolve URL (%s): %s' % (action, url)) if xbmc.Player().isPlaying(): utils.show_info_notification(utils.translation(32007), 1000) else: utils.show_info_notification(utils.translation(32007)) if 'youtube.com' in url or 'youtu.be' in url: youtube_addon = xbmcaddon.Addon(id="plugin.video.youtube") if youtube_addon: if youtube_addon.getSetting("kodion.video.quality.mpd") == "true": logger.info(u'Youtube addon have DASH enabled use it') utils.play_url('plugin://plugin.video.youtube/uri2addon/?uri=%s' % url, action) return logger.info(u'Trying to resolve with YoutubeDL') result = resolve_with_youtube_dl(url, {'format': 'best', 'no_color': 'true', 'ignoreerrors': 'true'}, action) if result: return # Second pass with new params to fix site like reddit dash streams logger.info(u'Trying to resolve with YoutubeDL other options') result = resolve_with_youtube_dl(url, {'format': 'bestvideo+bestaudio/best', 'no_color': 'true', 'ignoreerrors': 'true'}, action) if result: return logger.error(u'Url not resolved by YoutubeDL') if utils.is_python_3(): logger.info(u'Skipping urlResolver as running on Python 3') else: logger.info(u'Trying to resolve with urlResolver') stream_url = urlresolver.HostedMediaFile(url=url).resolve() if stream_url: logger.info(u'Url resolved by urlResolver: %s' % stream_url) utils.play_url(stream_url, action) return logger.info(u'Trying to play as basic url') utils.play_url(url, action) if url: utils.show_error_notification(utils.translation(32006))
# -*- coding: utf-8 -*- import sys sys.argv.insert( 1, 0) # Stupid hack as calling scripts from JSON does not add script handle import xbmcgui import xbmcaddon from lib import share, stream, utils from lib.utils import logger, translation logger.info("Starting script version: %s", utils.ADDON_VERSION) argument = {} for arg in sys.argv[2:]: argInfo = arg.split('=') argument[argInfo[0]] = argInfo[1] logger.info("Parameters: %s" % argument) commands = {'share': share.run, 'stream': stream.run} if 'action' not in argument: xbmcaddon.Addon().openSettings() else: if argument['action'] in commands: commands[argument['action']](argument) else: logger.error("Command not supported: %s" % argument['action']) xbmcgui.Dialog().ok(utils.ADDON_NAME, translation(32004),