def test_run_strred_fextractor(self): print 'test on running STRRED feature extractor...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.fextractor = StrredFeatureExtractor( [asset, asset_original], None, fifo_mode=True, result_store=None ) self.fextractor.run(parallelize=True) results = self.fextractor.results self.assertAlmostEqual(results[0]['STRRED_feature_srred_score'], 3.0114681041666671, places=4) self.assertAlmostEqual(results[0]['STRRED_feature_trred_score'], 7.3039486249999994, places=4) self.assertAlmostEqual(results[0]['STRRED_feature_strred_score'], 21.995608318659482, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_srred_score'], 0.0, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_trred_score'], 0.0, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_strred_score'], 0.0, places=4)
def test_run_dis_yuv_raw_video_extractor_parallel(self): print 'test on running dis YUV raw video extractor...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) h5py_file = DisYUVRawVideoExtractor.open_h5py_file(self.h5py_filepath) self.fextractor = DisYUVRawVideoExtractor( [asset, asset_original], None, fifo_mode=False, optional_dict={'channels': 'yu'}, optional_dict2={'h5py_file': h5py_file} ) with self.assertRaises(AssertionError): self.fextractor.run(parallelize=True) DisYUVRawVideoExtractor.close_h5py_file(h5py_file)
def test_run_psnr_fextractor(self): print 'test on running PSNR feature extractor...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.fextractor = PsnrFeatureExtractor( [asset, asset_original], None, fifo_mode=True, result_store=None ) self.fextractor.run() results = self.fextractor.results self.assertAlmostEqual(results[0]['PSNR_feature_psnr_score'], 30.755063979166664, places=4) self.assertAlmostEqual(results[1]['PSNR_feature_psnr_score'], 60.0, places=4)
def test_run_parallel_moment_noref_fextractor(self): print 'test on running Moment noref feature extractor on NorefAssets in parallel...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = NorefAsset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = NorefAsset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), dis_path=ref_path, asset_dict={'width':576, 'height':324}) fextractor = MomentNorefFeatureExtractor( [asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, ) self.fextractors = [fextractor] fextractor.run(parallelize=True) results = fextractor.results self.assertAlmostEqual(results[0]['Moment_noref_feature_1st_score'], 61.332006624999984) self.assertAlmostEqual(results[0]['Moment_noref_feature_2nd_score'], 4798.659574041666) self.assertAlmostEqual(results[0]['Moment_noref_feature_var_score'], 1036.8371843488285) self.assertAlmostEqual(results[1]['Moment_noref_feature_1st_score'], 59.788567297525134) self.assertAlmostEqual(results[1]['Moment_noref_feature_2nd_score'], 4696.668388042271) self.assertAlmostEqual(results[1]['Moment_noref_feature_var_score'], 1121.519917231207)
def test_run_vmaf_fextractor_with_resampling(self): ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324, 'quality_width':160, 'quality_height':90}) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324, 'quality_width':160, 'quality_height':90}) self.fextractor = VmafFeatureExtractor( [asset, asset_original], None, fifo_mode=False) self.fextractor.run(parallelize=False) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.782546520833, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'],1.3216766875, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_score'], 0.98229347916666665, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 28.0085990417, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 1.3216766875, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 31.811350125, places=4)
def test_explain_vmaf_results(self): print 'test on running VMAF runner with local explainer...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.runner = VmafQualityRunnerWithLocalExplainer( [asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict2={'explainer': LocalExplainer(neighbor_samples=100)} ) np.random.seed(0) self.runner.run() results = self.runner.results self.assertAlmostEqual(results[0]['VMAF_score'], 76.699271272486044, places=4) self.assertAlmostEqual(results[1]['VMAF_score'], 99.946416604585025, places=4) expected_feature_names = ['VMAF_feature_adm2_score', 'VMAF_feature_motion2_score', 'VMAF_feature_vif_scale0_score', 'VMAF_feature_vif_scale1_score', 'VMAF_feature_vif_scale2_score', 'VMAF_feature_vif_scale3_score'] weights = np.mean(results[0]['VMAF_scores_exps']['feature_weights'], axis=0) self.assertAlmostEqual(weights[0], 0.66021689480916868, places=4) self.assertAlmostEqual(weights[1], 0.14691682562211777, places=4) self.assertAlmostEqual(weights[2], -0.023682744847036086, places=4) self.assertAlmostEqual(weights[3], -0.029779341850172818, places=4) self.assertAlmostEqual(weights[4], 0.19149485210137338, places=4) self.assertAlmostEqual(weights[5], 0.31890978778344126, places=4) self.assertEqual(results[0]['VMAF_scores_exps']['feature_names'], expected_feature_names) weights = np.mean(results[1]['VMAF_scores_exps']['feature_weights'], axis=0) self.assertAlmostEqual(weights[0], 0.69597961598838509, places=4) self.assertAlmostEqual(weights[1], 0.18256016705513464, places=4) self.assertAlmostEqual(weights[2], 0.0090048099912423147, places=4) self.assertAlmostEqual(weights[3], 0.028671810808880094, places=4) self.assertAlmostEqual(weights[4], 0.21935602577417926, places=4) self.assertAlmostEqual(weights[5], 0.34190431429767715, places=4) self.assertEqual(results[1]['VMAF_scores_exps']['feature_names'], expected_feature_names)
def test_run_parallel_ssim_fextractor(self): print 'test on running SSIM feature extractor in parallel...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.fextractor = SsimFeatureExtractor( [asset, asset_original, asset], None, fifo_mode=True, result_store=None ) self.fextractor.run(parallelize=True) results = self.fextractor.results self.assertAlmostEqual(results[0]['SSIM_feature_ssim_score'], 0.86322654166666657, places=4) self.assertAlmostEqual(results[0]['SSIM_feature_ssim_l_score'], 0.9981474583333334, places=4) self.assertAlmostEqual(results[0]['SSIM_feature_ssim_c_score'], 0.96126793750000006, places=4) self.assertAlmostEqual(results[0]['SSIM_feature_ssim_s_score'], 0.89773633333333336, places=4) self.assertAlmostEqual(results[1]['SSIM_feature_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['SSIM_feature_ssim_l_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['SSIM_feature_ssim_c_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['SSIM_feature_ssim_s_score'], 1.0, places=4) self.assertAlmostEqual(results[2]['SSIM_feature_ssim_score'], 0.86322654166666657, places=4)
def test_run_asset_extractor(self): print 'test on running asset extractor...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324, 'quality_width':160, 'quality_height':90}) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324, 'quality_width':160, 'quality_height':90}) self.fextractor = AssetExtractor( [asset, asset_original], None, fifo_mode=True) self.fextractor.run() results = self.fextractor.results self.assertEqual(str(results[0]['asset']), 'test_0_1_src01_hrc00_576x324_576x324_vs_src01_hrc01_576x324_576x324_q_160x90') self.assertEqual(str(results[1]['asset']), 'test_0_2_src01_hrc00_576x324_576x324_vs_src01_hrc00_576x324_576x324_q_160x90') self.fextractor.run(parallelize=True) results = self.fextractor.results self.assertEqual(str(results[0]['asset']), 'test_0_1_src01_hrc00_576x324_576x324_vs_src01_hrc01_576x324_576x324_q_160x90') self.assertEqual(str(results[1]['asset']), 'test_0_2_src01_hrc00_576x324_576x324_vs_src01_hrc00_576x324_576x324_q_160x90')
def test_run_vmaf_fextractor_checkerboard(self): print 'test on running VMAF feature extractor on checkerboard...' ref_path = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv") dis_path = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_10_0.yuv") dis_path2 = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_1_0.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':1920, 'height':1080}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':1920, 'height':1080}) asset2 = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path2, asset_dict={'width':1920, 'height':1080}) self.fextractor = VmafFeatureExtractor( [asset, asset_original, asset2], None, fifo_mode=True, result_store=None ) self.fextractor.run() results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_adm_score'], 0.053996333333333334, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'], 0.053996333333333334, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_scale0_score'], 0.23738393128710478, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_scale1_score'], 0.08524788663335138, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_scale2_score'], 0.024058909404945077, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_scale3_score'], 0.018034879735107798, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 12.554836666666667, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion2_score'], 12.554836666666667, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_scale0_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_scale1_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_scale2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_scale3_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 12.554836666666667, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion2_score'], 12.554836666666667, places=4) self.assertAlmostEqual(results[2]['VMAF_feature_adm_score'], 0.78533833333333336, places=4) self.assertAlmostEqual(results[2]['VMAF_feature_adm2_score'], 0.7853384465157921, places=4) self.assertAlmostEqual(results[2]['VMAF_feature_adm_scale0_score'], 0.72132189911792899, places=4) self.assertAlmostEqual(results[2]['VMAF_feature_adm_scale1_score'], 0.69259738857522501, places=4) self.assertAlmostEqual(results[2]['VMAF_feature_adm_scale2_score'], 0.80415911639244586, places=4) self.assertAlmostEqual(results[2]['VMAF_feature_adm_scale3_score'], 0.82791889676239039, places=4) self.assertAlmostEqual(results[2]['VMAF_feature_motion_score'], 12.554836666666667, places=4) self.assertAlmostEqual(results[2]['VMAF_feature_motion2_score'], 12.554836666666667, places=4)
def test_run_ms_ssim_fextractor(self): print 'test on running MS-SSIM feature extractor...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.fextractor = MsSsimFeatureExtractor( [asset, asset_original], None, fifo_mode=True, result_store=None ) self.fextractor.run() results = self.fextractor.results self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_score'], 0.9632498125, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_l_scale0_score'], 0.9981474583333334, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_c_scale0_score'], 0.96126793750000006, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_s_scale0_score'], 0.89773633333333336, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_l_scale1_score'], 0.99899612500000001, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_c_scale1_score'], 0.9857694375, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_s_scale1_score'], 0.941185875, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_l_scale2_score'], 0.99923564583333324, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_c_scale2_score'], 0.997034020833, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_s_scale2_score'], 0.977992145833, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_l_scale3_score'], 0.99929210416666658, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_c_scale3_score'], 0.999588104167, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_s_scale3_score'], 0.99387125, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_l_scale4_score'], 0.99940356249999995, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_c_scale4_score'], 0.999907625, places=4) self.assertAlmostEqual(results[0]['MS_SSIM_feature_ms_ssim_s_scale4_score'], 0.998222583333, places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_l_scale0_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_c_scale0_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_s_scale0_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_l_scale1_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_c_scale1_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_s_scale1_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_l_scale2_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_c_scale2_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_s_scale2_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_l_scale3_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_c_scale3_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_s_scale3_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_l_scale4_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_c_scale4_score'], 1., places=4) self.assertAlmostEqual(results[1]['MS_SSIM_feature_ms_ssim_s_scale4_score'], 1., places=4)
def test_run_testlib_runner(self): print 'test on running TESTLIB runner...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.runner = TestLibRunner( [asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, ) self.runner.run() results = self.runner.results self.assertAlmostEqual(results[0]['TESTLIB_vif_scale0_score'],0.363420458333, places=4) self.assertAlmostEqual(results[0]['TESTLIB_vif_scale1_score'], 0.766647520833, places=4) self.assertAlmostEqual(results[0]['TESTLIB_vif_scale2_score'], 0.862854708333, places=4) self.assertAlmostEqual(results[0]['TESTLIB_vif_scale3_score'], 0.915971791667, places=4) self.assertAlmostEqual(results[0]['TESTLIB_motion2_score'], 3.8953518541666665, places=4) self.assertAlmostEqual(results[0]['TESTLIB_adm2_score'], 0.93458777083333333, places=4) self.assertAlmostEqual(results[0]['TESTLIB_psnr_score'], 30.7550666667, places=4) self.assertAlmostEqual(results[0]['TESTLIB_ssim_score'], 0.86322654166666657, places=4) self.assertAlmostEqual(results[0]['TESTLIB_ms_ssim_score'], 0.9632498125, places=4) self.assertAlmostEqual(results[1]['TESTLIB_vif_scale0_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['TESTLIB_vif_scale1_score'],0.999999958333, places=4) self.assertAlmostEqual(results[1]['TESTLIB_vif_scale2_score'],0.999999416667, places=4) self.assertAlmostEqual(results[1]['TESTLIB_vif_scale3_score'], 0.999999208333, places=4) self.assertAlmostEqual(results[1]['TESTLIB_motion2_score'], 3.8953518541666665, places=4) self.assertAlmostEqual(results[1]['TESTLIB_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['TESTLIB_psnr_score'], 60.0, places=4) self.assertAlmostEqual(results[1]['TESTLIB_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['TESTLIB_ms_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['TESTLIB_score'], 76.699271272486044, places=3) self.assertAlmostEqual(results[1]['TESTLIB_score'],99.946416604585025, places=4)
def test_run_strred_fextractor_blackframes(self): print 'test on running STRRED feature extractor on flat frames...' ref_path = VmafConfig.test_resource_path("yuv", "flat_1920_1080_0.yuv") dis_path = VmafConfig.test_resource_path("yuv", "flat_1920_1080_10.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) from vmaf.core.result_store import FileSystemResultStore result_store = FileSystemResultStore(logger=None) self.fextractor = StrredFeatureExtractor( [asset, asset_original], None, fifo_mode=True, result_store=result_store ) print ' running for the first time with fresh calculation...' self.fextractor.run(parallelize=True) result0, result1 = self.fextractor.results import os self.assertTrue(os.path.exists(result_store._get_result_file_path(result0))) self.assertTrue(os.path.exists(result_store._get_result_file_path(result1))) print ' running for the second time with stored results...' self.fextractor.run(parallelize=True) results = self.fextractor.results # ignore NaN for result in results: result.set_score_aggregate_method(ListStats.nonemean) self.assertAlmostEqual(results[0]['STRRED_feature_srred_score'], 1220.5679849999999, places=4) self.assertAlmostEqual(results[0]['STRRED_feature_trred_score'], 50983.3097155, places=4) self.assertAlmostEqual(results[0]['STRRED_feature_strred_score'], 62228595.6081, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_srred_score'], 0.0, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_trred_score'], 0.0, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_strred_score'], 0.0, places=4)
def test_feature_assembler_selected_atom_feature(self): print 'test on feature assembler with selected atom features...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.fassembler = FeatureAssembler( feature_dict={'VMAF_feature':['vif', 'motion']}, feature_option_dict=None, assets=[asset, asset_original], logger=None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=None, optional_dict2=None, parallelize=True, ) self.fassembler.run() results = self.fassembler.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.44609306249999997, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 4.0498253541666669, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 4.0498253541666669, places=4) with self.assertRaises(KeyError): results[0]['VMAF_feature_ansnr_scores'] with self.assertRaises(KeyError): results[0]['VMAF_feature_ansnr_score'] with self.assertRaises(KeyError): results[0]['VMAF_feature_adm_scores'] with self.assertRaises(KeyError): results[0]['VMAF_feature_adm_score']
def test_run_vmaf_fextractor_with_cropping_and_padding_to_original_wh(self): # crop_cmd: 288:162:144:81 - crop to the center 288x162 image # pad_cmd: iw+288:ih+162:144:81 - pad back to the original size ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324, 'crop_cmd':'288:162:144:81', 'pad_cmd': 'iw+288:ih+162:144:81', 'quality_width':576, 'quality_height':324, }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324, 'crop_cmd':'288:162:144:81', 'pad_cmd': 'iw+288:ih+162:144:81', 'quality_width':576, 'quality_height':324, }) self.fextractor = VmafFeatureExtractor( [asset, asset_original], None, fifo_mode=True) self.fextractor.run(parallelize=True) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.64106379166666672, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 0.7203213958333331, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'],0.94700196017089999, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 32.78451041666667, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 0.7203213958333331, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 40.280504208333333, places=4)
def test_feature_assembler_whole_feature(self): print 'test on feature assembler with whole feature...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.fassembler = FeatureAssembler( feature_dict={'VMAF_feature':'all'}, feature_option_dict=None, assets=[asset, asset_original], logger=None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=None, optional_dict2=None, parallelize=True, ) self.fassembler.run() results = self.fassembler.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.44609306249999997, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 4.0498253541666669, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'], 0.93458780728708746, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 23.509571520833333, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 4.0498253541666669, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 31.271439270833337, places=4)
def test_run_parallel_dis_y_fextractor(self): print 'test on running dis YUV raw video extractor in parallel (disabled)...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) h5py_file = DisYUVRawVideoExtractor.open_h5py_file(self.h5py_filepath) optional_dict2 = {'h5py_file': h5py_file} fextractor = DisYUVRawVideoExtractor( [asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict={'channels': 'yu'}, optional_dict2=optional_dict2 ) self.fextractors = [fextractor] fextractor.run(parallelize=False) # Can't run parallel: can't pickle FileID objects results = fextractor.results self.assertAlmostEqual(np.mean(results[0]['dis_y']), 61.332006579182384, places=4) self.assertAlmostEquals(np.mean(results[1]['dis_y']), 59.788567297525148, places=4) self.assertAlmostEqual(np.mean(results[0]['dis_u']), 115.23227407335962, places=4) self.assertAlmostEquals(np.mean(results[1]['dis_u']), 114.49701717535437, places=4) with self.assertRaises(KeyError): np.mean(results[0]['dis_v']) DisYUVRawVideoExtractor.close_h5py_file(h5py_file)
def test_run_vmaf_fextractor_with_padding(self): # pad_cmd: iw+100:ih+100:50:50 - pad to (iw+100)x(ih+100), where iw is # input width, ih is input height, and starting point is (-50, -50) ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324, 'pad_cmd': 'iw+100:ih+100:50:50', 'quality_width':676, 'quality_height':424, }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324, 'pad_cmd': 'iw+100:ih+100:50:50', 'quality_width':676, 'quality_height':424, }) self.fextractor = VmafFeatureExtractor( [asset, asset_original], None, fifo_mode=True) self.fextractor.run(parallelize=False) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.51023564583333325, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 2.6397702083333332, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'],0.94112949409549829, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 26.893242291666667, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 2.6397702083333332, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 34.306043416666668, places=4)
def test_run_vmaf_fextractor_with_cropping(self): # crop_cmd: 288:162:144:81 - crop to 288x162 with upper-left pixel # starting at coordinate (144, 81) ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324, 'crop_cmd':'288:162:144:81', 'quality_width':288, 'quality_height':162, }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324, 'crop_cmd':'288:162:144:81', 'quality_width':288, 'quality_height':162, }) self.fextractor = VmafFeatureExtractor( [asset, asset_original], None, fifo_mode=False) self.fextractor.run(parallelize=False) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.45365762500000012, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 2.8779373333333331, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'],0.93894987889874548, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 23.942050354166668, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 2.8779373333333331, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 31.71648420833333, places=4)
def test_run_vmaf_fextractor_flat(self): print 'test on running VMAF feature extractor on flat pattern...' ref_path = VmafConfig.test_resource_path("yuv", "flat_1920_1080_0.yuv") dis_path = VmafConfig.test_resource_path("yuv", "flat_1920_1080_10.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':1920, 'height':1080}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':1920, 'height':1080}) self.fextractor = VmafFeatureExtractor( [asset, asset_original], None, fifo_mode=True, result_store=None ) self.fextractor.run() results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_adm_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_scale0_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_scale1_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_scale2_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_scale3_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_scale0_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_scale1_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_scale2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_scale3_score'], 1.0, places=4)
def test_run_parallel_moment_fextractor(self): print 'test on running Moment feature extractor in parallel...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':576, 'height':324}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width':576, 'height':324}) self.fextractor = MomentFeatureExtractor( [asset, asset_original, asset], None, fifo_mode=True, result_store=None ) self.fextractor.run(parallelize=True) results = self.fextractor.results self.assertAlmostEqual(results[0]['Moment_feature_ref1st_score'], 59.788567297525134, places=4) self.assertAlmostEqual(results[0]['Moment_feature_ref2nd_score'], 4696.668388042269, places=4) self.assertAlmostEqual(results[0]['Moment_feature_refvar_score'], 1121.519917231203, places=4) self.assertAlmostEqual(results[0]['Moment_feature_dis1st_score'], 61.332006624999984, places=4) self.assertAlmostEqual(results[0]['Moment_feature_dis2nd_score'], 4798.659574041666, places=4) self.assertAlmostEqual(results[0]['Moment_feature_disvar_score'], 1036.837184348847, places=4) self.assertAlmostEqual(results[1]['Moment_feature_ref1st_score'], 59.788567297525134, places=4) self.assertAlmostEqual(results[1]['Moment_feature_ref2nd_score'], 4696.668388042269, places=4) self.assertAlmostEqual(results[1]['Moment_feature_refvar_score'], 1121.519917231203, places=4) self.assertAlmostEqual(results[1]['Moment_feature_dis1st_score'], 59.788567297525134, places=4) self.assertAlmostEqual(results[1]['Moment_feature_dis2nd_score'], 4696.668388042269, places=4) self.assertAlmostEqual(results[1]['Moment_feature_disvar_score'], 1121.519917231203, places=4) self.assertAlmostEqual(results[2]['Moment_feature_ref1st_score'], 59.788567297525134, places=4)
def setUp(self): ref_path = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv") dis_path = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_1_0.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':1920, 'height':1080}) self.runner = VmafLegacyQualityRunner( [asset], None, fifo_mode=True, delete_workdir=True, result_store=None, ) self.runner.run() self.result = self.runner.results[0]
def setUp(self): train_dataset_path = VmafConfig.test_resource_path("test_image_dataset_diffdim.py") train_dataset = import_python_file(train_dataset_path) train_assets = read_dataset(train_dataset) self.h5py_filepath = VmafConfig.workdir_path('test.hdf5') self.h5py_file = DisYUVRawVideoExtractor.open_h5py_file(self.h5py_filepath) optional_dict2 = {'h5py_file': self.h5py_file} fextractor = DisYUVRawVideoExtractor( train_assets, None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=None, optional_dict2=optional_dict2, ) fextractor.run(parallelize=False) # CAN ONLY USE SERIAL MODE FOR DisYRawVideoExtractor self.features = fextractor.results
def test_noref_moment_fextractor_frames(self): print 'test on running Moment noref feature extractor on Assets with frames...' dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = NorefAsset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), dis_path=dis_path, asset_dict={'width':576, 'height':324, 'start_frame':2, 'end_frame':2, }) self.fextractor = MomentNorefFeatureExtractor( [asset], None, fifo_mode=True, result_store=None ) self.fextractor.run() results = self.fextractor.results self.assertAlmostEqual(results[0]['Moment_noref_feature_1st_score'], 62.315495327503427, places=4) self.assertAlmostEqual(results[0]['Moment_noref_feature_2nd_score'], 4888.7623296039092, places=4) self.assertAlmostEqual(results[0]['Moment_noref_feature_var_score'], 1005.5413716918079, places=4)
def test_noref_moment_fextractor_with_noref_asset_notyuv(self): print 'test on running Moment noref feature extractor on NorefAssets ' \ '(non-YUV)...' dis_path = VmafConfig.test_resource_path("mp4", "Seeking_10_288_375.mp4") asset = NorefAsset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), dis_path=dis_path, asset_dict={'yuv_type': 'notyuv', 'quality_width': 720, 'quality_height': 480, }) self.fextractor = MomentNorefFeatureExtractor( [asset], None, fifo_mode=True, result_store=None ) self.fextractor.run() results = self.fextractor.results self.assertAlmostEqual(results[0]['Moment_noref_feature_1st_score'], 63.763580381944436, places=4) self.assertAlmostEqual(results[0]['Moment_noref_feature_2nd_score'], 5158.9407083526221, places=4) self.assertAlmostEqual(results[0]['Moment_noref_feature_var_score'], 1084.1635630076041, places=4)
def setUp(self): self.dataset_filename = VmafConfig.test_resource_path('example_dataset.py') self.raw_dataset_filename = VmafConfig.test_resource_path('example_raw_dataset.py') self.out_model_filepath = VmafConfig.workdir_path('tmp.pkl') self.param_filename = VmafConfig.test_resource_path('vmaf_v4.py') self.batch_filename = VmafConfig.workdir_path('test_batch_input')
def main(): if len(sys.argv) < 6: print_usage() return 2 try: fmt = sys.argv[1] width = int(sys.argv[2]) height = int(sys.argv[3]) ref_path = sys.argv[4] dis_path = sys.argv[5] except ValueError: print_usage() return 2 if width < 0 or height < 0: print "width and height must be non-negative, but are {w} and {h}".format(w=width, h=height) print_usage() return 2 if fmt not in FMTS: print_usage() return 2 out_fmt = get_cmd_option(sys.argv, 6, len(sys.argv), '--out-fmt') if not (out_fmt is None or out_fmt == 'xml' or out_fmt == 'json' or out_fmt == 'text'): print_usage() return 2 pool_method = get_cmd_option(sys.argv, 6, len(sys.argv), '--pool') if not (pool_method is None or pool_method in POOL_METHODS): print '--pool can only have option among {}'.format(', '.join(POOL_METHODS)) return 2 asset = Asset(dataset="cmd", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':width, 'height':height, 'yuv_type':fmt} ) assets = [asset] runner_class = PsnrQualityRunner runner = runner_class( assets, None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=None, optional_dict2=None, ) # run runner.run() result = runner.results[0] # pooling if pool_method == 'harmonic_mean': result.set_score_aggregate_method(ListStats.harmonic_mean) elif pool_method == 'min': result.set_score_aggregate_method(np.min) elif pool_method == 'median': result.set_score_aggregate_method(np.median) elif pool_method == 'perc5': result.set_score_aggregate_method(ListStats.perc5) elif pool_method == 'perc10': result.set_score_aggregate_method(ListStats.perc10) elif pool_method == 'perc20': result.set_score_aggregate_method(ListStats.perc20) else: # None or 'mean' pass # output if out_fmt == 'xml': print result.to_xml() elif out_fmt == 'json': print result.to_json() else: # None or 'text' print str(result) return 0
def test_run_vmaf_fextractor_with_gaussian_blurring(self): ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324, 'crop_cmd': '288:162:144:81', 'dis_gblur_cmd': 'sigma=0.01:steps=1', 'quality_width': 288, 'quality_height': 162, }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324, 'crop_cmd': '288:162:144:81', 'dis_gblur_cmd': 'sigma=0.01:steps=2', 'quality_width': 288, 'quality_height': 162, }) self.fextractor = VmafFeatureExtractor([asset, asset_original], None, fifo_mode=True) self.fextractor.run(parallelize=True) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.45136466666666664, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 2.8779373333333331, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'], 0.9362876630569382, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 24.110899416666665, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 0.9789283541666666, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 2.8779373333333331, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 0.9958889086049826, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 31.128021979166665, places=4)
def test_run_vmafrc_compare_directly_with_ossexec_420_10bit(self): ref_path = VmafConfig.test_resource_path("yuv", "sparks_ref_480x270.yuv42010le.yuv") dis_path = VmafConfig.test_resource_path("yuv", "sparks_dis_480x270.yuv42010le.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width': 480, 'height': 270, 'yuv_type': 'yuv420p10le'}) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={'width': 480, 'height': 270, 'yuv_type': 'yuv420p10le'}) self.runner = VmafrcQualityRunner( [asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict={ 'float_psnr': True, 'float_ssim': True, 'float_ms_ssim': True, 'psnr': True, 'ssim': True, 'ms_ssim': False, } ) self.runner.run(parallelize=True) results_rc = self.runner.results self.runner = VmafossExecQualityRunner( [asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, ) self.runner.run(parallelize=True) results = self.runner.results self.assertAlmostEqual(results_rc[0]['VMAFRC_vif_scale0_score'], results[0]['VMAFOSSEXEC_vif_scale0_score'], places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_vif_scale1_score'], results[0]['VMAFOSSEXEC_vif_scale1_score'], places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_vif_scale2_score'], results[0]['VMAFOSSEXEC_vif_scale2_score'], places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_vif_scale3_score'], results[0]['VMAFOSSEXEC_vif_scale3_score'], places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_motion2_score'], results[0]['VMAFOSSEXEC_motion2_score'], places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_adm2_score'], results[0]['VMAFOSSEXEC_adm2_score'], places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_float_psnr_score'], results[0]['VMAFOSSEXEC_psnr_score'], places=4) self.assertAlmostEqual(results_rc[0]['VMAFRC_float_ssim_score'], results[0]['VMAFOSSEXEC_ssim_score'], places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_float_ms_ssim_score'], results[0]['VMAFOSSEXEC_ms_ssim_score'], places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_psnr_y_score'], results[0]['VMAFOSSEXEC_psnr_score'], places=4) self.assertAlmostEqual(results_rc[0]['VMAFRC_psnr_cb_score'], 50.2879106, places=4) self.assertAlmostEqual(results_rc[0]['VMAFRC_psnr_cr_score'], 49.740259, places=4) self.assertAlmostEqual(results_rc[0]['VMAFRC_ssim_score'], 0.9957616000000001, places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_vif_scale0_score'], results[1]['VMAFOSSEXEC_vif_scale0_score'], places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_vif_scale1_score'], results[1]['VMAFOSSEXEC_vif_scale1_score'], places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_vif_scale2_score'], results[1]['VMAFOSSEXEC_vif_scale2_score'], places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_vif_scale3_score'], results[1]['VMAFOSSEXEC_vif_scale3_score'], places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_motion2_score'], results[1]['VMAFOSSEXEC_motion2_score'], places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_adm2_score'], results[1]['VMAFOSSEXEC_adm2_score'], places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_float_psnr_score'], results[1]['VMAFOSSEXEC_psnr_score'], places=4) self.assertAlmostEqual(results_rc[1]['VMAFRC_float_ssim_score'], results[1]['VMAFOSSEXEC_ssim_score'], places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_float_ms_ssim_score'], results[1]['VMAFOSSEXEC_ms_ssim_score'], places=5) self.assertAlmostEqual(results_rc[1]['VMAFRC_psnr_y_score'], results[1]['VMAFOSSEXEC_psnr_score'], places=4) self.assertAlmostEqual(results_rc[1]['VMAFRC_psnr_cb_score'], 72.0, places=4) self.assertAlmostEqual(results_rc[1]['VMAFRC_psnr_cr_score'], 72.0, places=4) self.assertAlmostEqual(results_rc[1]['VMAFRC_ssim_score'], 1.0, places=5) self.assertAlmostEqual(results_rc[0]['VMAFRC_score'], results[0]['VMAFOSSEXEC_score'], places=4) self.assertAlmostEqual(results_rc[1]['VMAFRC_score'], results[1]['VMAFOSSEXEC_score'], places=4)
def test_run_vmaf_fextractor_with_cropping_and_padding_to_original_wh( self): # crop_cmd: 288:162:144:81 - crop to the center 288x162 image # pad_cmd: iw+288:ih+162:144:81 - pad back to the original size ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324, 'crop_cmd': '288:162:144:81', 'pad_cmd': 'iw+288:ih+162:144:81', 'quality_width': 576, 'quality_height': 324, }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324, 'crop_cmd': '288:162:144:81', 'pad_cmd': 'iw+288:ih+162:144:81', 'quality_width': 576, 'quality_height': 324, }) self.fextractor = VmafFeatureExtractor([asset, asset_original], None, fifo_mode=True) self.fextractor.run(parallelize=True) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.64106379166666672, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 0.7203213958333331, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'], 0.9469305256822512, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 32.78451041666667, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 0.7203213958333331, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 40.280504208333333, places=4)
def setUp(self): self.h5py_filepath = VmafConfig.workdir_path('test.hdf5')
def test_explain_vmaf_results(self): ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324 }) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324 }) self.runner = VmafQualityRunnerWithLocalExplainer( [asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict={ 'model_filepath': VmafConfig.model_path("vmaf_float_v0.6.1.json") }, optional_dict2={'explainer': LocalExplainer(neighbor_samples=100)}) np.random.seed(0) self.runner.run() results = self.runner.results self.assertAlmostEqual(results[0]['VMAF_score'], 76.68425574067017, places=4) self.assertAlmostEqual(results[1]['VMAF_score'], 99.946416604585025, places=4) expected_feature_names = [ 'VMAF_feature_adm2_score', 'VMAF_feature_motion2_score', 'VMAF_feature_vif_scale0_score', 'VMAF_feature_vif_scale1_score', 'VMAF_feature_vif_scale2_score', 'VMAF_feature_vif_scale3_score' ] weights = np.mean(results[0]['VMAF_scores_exps']['feature_weights'], axis=0) self.assertAlmostEqual(weights[0], 0.66021689480916868, places=4) self.assertAlmostEqual(weights[1], 0.14691682562211777, places=4) self.assertAlmostEqual(weights[2], -0.023682744847036086, places=4) self.assertAlmostEqual(weights[3], -0.029779341850172818, places=4) self.assertAlmostEqual(weights[4], 0.19149485210137338, places=4) self.assertAlmostEqual(weights[5], 0.31890978778344126, places=4) self.assertEqual(results[0]['VMAF_scores_exps']['feature_names'], expected_feature_names) weights = np.mean(results[1]['VMAF_scores_exps']['feature_weights'], axis=0) self.assertAlmostEqual(weights[0], 0.69597961598838509, places=4) self.assertAlmostEqual(weights[1], 0.18256016705513464, places=4) self.assertAlmostEqual(weights[2], 0.0090048099912423147, places=4) self.assertAlmostEqual(weights[3], 0.028671810808880094, places=4) self.assertAlmostEqual(weights[4], 0.21935602577417926, places=4) self.assertAlmostEqual(weights[5], 0.34190431429767715, places=4) self.assertEqual(results[1]['VMAF_scores_exps']['feature_names'], expected_feature_names)
def test_run_vmafrc_runner_yuv422p10le(self): ref_path = VmafConfig.test_resource_path( "yuv", "src01_hrc00_576x324.yuv422p10le.yuv") dis_path = VmafConfig.test_resource_path( "yuv", "src01_hrc01_576x324.yuv422p10le.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324, 'yuv_type': 'yuv422p10le' }) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324, 'yuv_type': 'yuv422p10le' }) self.runner = VmafrcQualityRunner([asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict={ 'float_psnr': True, 'float_ssim': True, 'float_ms_ssim': True, }) self.runner.run() results = self.runner.results self.assertAlmostEqual(results[0]['VMAFRC_vif_scale0_score'], 0.3634208125, places=4) self.assertAlmostEqual(results[0]['VMAFRC_vif_scale1_score'], 0.7666474166666667, places=4) self.assertAlmostEqual(results[0]['VMAFRC_vif_scale2_score'], 0.8628533333333334, places=4) self.assertAlmostEqual(results[0]['VMAFRC_vif_scale3_score'], 0.9159719583333334, places=4) self.assertAlmostEqual(results[0]['VMAFRC_motion2_score'], 3.895352291666667, places=4) self.assertAlmostEqual(results[0]['VMAFRC_adm2_score'], 0.9345877291666667, places=4) self.assertAlmostEqual(results[0]['VMAFRC_float_psnr_score'], 30.780577083333331, places=4) self.assertAlmostEqual(results[0]['VMAFRC_float_ssim_score'], 0.86322654166666657, places=4) self.assertAlmostEqual(results[0]['VMAFRC_float_ms_ssim_score'], 0.9632406874999999, places=4) self.assertAlmostEqual(results[1]['VMAFRC_vif_scale0_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAFRC_vif_scale1_score'], 0.9999998541666666, places=4) self.assertAlmostEqual(results[1]['VMAFRC_vif_scale2_score'], 0.9999996041666667, places=4) self.assertAlmostEqual(results[1]['VMAFRC_vif_scale3_score'], 0.9999991458333334, places=4) self.assertAlmostEqual(results[1]['VMAFRC_motion2_score'], 3.895352291666667, places=4) self.assertAlmostEqual(results[1]['VMAFRC_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAFRC_float_psnr_score'], 72.0, places=4) self.assertAlmostEqual(results[1]['VMAFRC_float_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAFRC_float_ms_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['VMAFRC_score'], 76.69926875, places=4) self.assertAlmostEqual(results[1]['VMAFRC_score'], 99.94641666666666, places=4)
def test_run_asset_extractor(self): ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324, 'quality_width': 160, 'quality_height': 90 }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324, 'quality_width': 160, 'quality_height': 90 }) self.fextractor = AssetExtractor([asset, asset_original], None, fifo_mode=True) self.fextractor.run() results = self.fextractor.results self.assertEqual( str(results[0]['asset']), 'test_0_1_src01_hrc00_576x324_576x324_vs_src01_hrc01_576x324_576x324_q_160x90' ) self.assertEqual( str(results[1]['asset']), 'test_0_2_src01_hrc00_576x324_576x324_vs_src01_hrc00_576x324_576x324_q_160x90' ) self.fextractor.run(parallelize=True) results = self.fextractor.results self.assertEqual( str(results[0]['asset']), 'test_0_1_src01_hrc00_576x324_576x324_vs_src01_hrc01_576x324_576x324_q_160x90' ) self.assertEqual( str(results[1]['asset']), 'test_0_2_src01_hrc00_576x324_576x324_vs_src01_hrc00_576x324_576x324_q_160x90' )
def read_dataset(dataset, **kwargs): groundtruth_key = kwargs['groundtruth_key'] if 'groundtruth_key' in kwargs else None skip_asset_with_none_groundtruth = kwargs['skip_asset_with_none_groundtruth'] \ if 'skip_asset_with_none_groundtruth' in kwargs else False # asserts, can add more to the list... assert hasattr(dataset, 'dataset_name') assert hasattr(dataset, 'ref_videos') assert hasattr(dataset, 'dis_videos') assert hasattr(dataset, 'yuv_fmt') or all(['yuv_fmt' in ref_video for ref_video in dataset.ref_videos]) data_set_name = dataset.dataset_name ref_videos = dataset.ref_videos dis_videos = dataset.dis_videos width = dataset.width if hasattr(dataset, 'width') else None height = dataset.height if hasattr(dataset, 'height') else None yuv_fmt = dataset.yuv_fmt if hasattr(dataset, 'yuv_fmt') else None quality_width = dataset.quality_width if hasattr(dataset, 'quality_width') else None quality_height = dataset.quality_height if hasattr(dataset, 'quality_height') else None resampling_type = dataset.resampling_type if hasattr(dataset, 'resampling_type') else None crop_cmd = dataset.crop_cmd if hasattr(dataset, 'crop_cmd') else None pad_cmd = dataset.pad_cmd if hasattr(dataset, 'pad_cmd') else None ref_dict = {} # dictionary of content_id -> path for ref videos for ref_video in ref_videos: ref_dict[ref_video['content_id']] = ref_video assets = [] for dis_video in dis_videos: if groundtruth_key is not None: groundtruth = dis_video[groundtruth_key] else: if 'dmos' in dis_video: groundtruth = dis_video['dmos'] elif 'mos' in dis_video: groundtruth = dis_video['mos'] elif 'groundtruth' in dis_video: groundtruth = dis_video['groundtruth'] else: groundtruth = None if 'os' in dis_video: raw_groundtruth = dis_video['os'] else: raw_groundtruth = None ref_video = ref_dict[dis_video['content_id']] ref_path = ref_video['path'] ref_yuv_fmt_ = yuv_fmt if yuv_fmt is not None else ref_dict[dis_video['content_id']]['yuv_fmt'] dis_yuv_fmt_ = dis_video['yuv_fmt'] if 'yuv_fmt' in dis_video else ref_yuv_fmt_ if width is not None: width_ = width elif 'width' in ref_video: width_ = ref_video['width'] # NOTE: width in ref_video not dis_video else: width_ = None if height is not None: height_ = height elif 'height' in ref_video: height_ = ref_video['height'] # NOTE: height in ref_video not dis_video else: height_ = None if quality_width is not None: quality_width_ = quality_width elif 'quality_width' in dis_video: quality_width_ = dis_video['quality_width'] else: quality_width_ = None if quality_height is not None: quality_height_ = quality_height elif 'quality_height' in dis_video: quality_height_ = dis_video['quality_height'] else: quality_height_ = None if resampling_type is not None: resampling_type_ = resampling_type elif 'resampling_type' in dis_video: resampling_type_ = dis_video['resampling_type'] else: resampling_type_ = None if crop_cmd is not None: crop_cmd_ = crop_cmd elif 'crop_cmd' in dis_video: crop_cmd_ = dis_video['crop_cmd'] else: crop_cmd_ = None if pad_cmd is not None: pad_cmd_ = pad_cmd elif 'pad_cmd' in dis_video: pad_cmd_ = dis_video['pad_cmd'] else: pad_cmd_ = None asset_dict = {'ref_yuv_type': ref_yuv_fmt_, 'dis_yuv_type': dis_yuv_fmt_} if width_ is not None: if asset_dict['ref_yuv_type'] != 'notyuv': asset_dict['ref_width'] = width_ if asset_dict['dis_yuv_type'] != 'notyuv': asset_dict['dis_width'] = width_ if height_ is not None: if asset_dict['ref_yuv_type'] != 'notyuv': asset_dict['ref_height'] = height_ if asset_dict['dis_yuv_type'] != 'notyuv': asset_dict['dis_height'] = height_ if groundtruth is not None: asset_dict['groundtruth'] = groundtruth if raw_groundtruth is not None: asset_dict['raw_groundtruth'] = raw_groundtruth if quality_width_ is not None: asset_dict['quality_width'] = quality_width_ if quality_height_ is not None: asset_dict['quality_height'] = quality_height_ if resampling_type_ is not None: asset_dict['resampling_type'] = resampling_type_ if crop_cmd_ is not None: asset_dict['crop_cmd'] = crop_cmd_ if pad_cmd_ is not None: asset_dict['pad_cmd'] = pad_cmd_ if groundtruth is None and skip_asset_with_none_groundtruth: pass else: asset = Asset(dataset=data_set_name, content_id=dis_video['content_id'], asset_id=dis_video['asset_id'], workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_video['path'], asset_dict=asset_dict, ) assets.append(asset) return assets
def main(): if len(sys.argv) < 2: print_usage() return 2 input_filepath = sys.argv[1] model_path = get_cmd_option(sys.argv, 2, len(sys.argv), '--model') out_fmt = get_cmd_option(sys.argv, 2, len(sys.argv), '--out-fmt') if not (out_fmt is None or out_fmt == 'xml' or out_fmt == 'json' or out_fmt == 'text'): print_usage() return 2 pool_method = get_cmd_option(sys.argv, 2, len(sys.argv), '--pool') if not (pool_method is None or pool_method in POOL_METHODS): print('--pool can only have option among {}'.format( ', '.join(POOL_METHODS))) return 2 parallelize = cmd_option_exists(sys.argv, 2, len(sys.argv), '--parallelize') phone_model = cmd_option_exists(sys.argv, 2, len(sys.argv), '--phone-model') enable_conf_interval = cmd_option_exists(sys.argv, 2, len(sys.argv), '--ci') assets = [] line_idx = 0 with open(input_filepath, "rt") as input_file: for line in input_file.readlines(): # match comment mo = re.match(r"^#", line) if mo: print("Skip commented line: {}".format(line)) continue # match whitespace mo = re.match(r"[\s]+", line) if mo: continue # example: yuv420p 576 324 ref.yuv dis.yuv mo = re.match(r"([\S]+) ([0-9]+) ([0-9]+) ([\S]+) ([\S]+)", line) if not mo or mo.group(1) not in FMTS: print("Unknown format: {}".format(line)) print_usage() return 1 fmt = mo.group(1) width = int(mo.group(2)) height = int(mo.group(3)) ref_file = mo.group(4) dis_file = mo.group(5) asset = Asset(dataset="cmd", content_id=0, asset_id=line_idx, workdir_root=VmafConfig.workdir_path(), ref_path=ref_file, dis_path=dis_file, asset_dict={ 'width': width, 'height': height, 'yuv_type': fmt }) assets.append(asset) line_idx += 1 if enable_conf_interval: from vmaf.core.quality_runner import BootstrapVmafQualityRunner runner_class = BootstrapVmafQualityRunner else: runner_class = VmafQualityRunner if model_path is None: optional_dict = None else: optional_dict = {'model_filepath': model_path} if phone_model: if optional_dict is None: optional_dict = {} optional_dict['enable_transform_score'] = True runner = runner_class( assets, None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=optional_dict, optional_dict2=None, ) runner.run(parallelize=parallelize) results = runner.results # output for result in results: # pooling if pool_method == 'harmonic_mean': result.set_score_aggregate_method(ListStats.harmonic_mean) elif pool_method == 'min': result.set_score_aggregate_method(np.min) elif pool_method == 'median': result.set_score_aggregate_method(np.median) elif pool_method == 'perc5': result.set_score_aggregate_method(ListStats.perc5) elif pool_method == 'perc10': result.set_score_aggregate_method(ListStats.perc10) elif pool_method == 'perc20': result.set_score_aggregate_method(ListStats.perc20) else: # None or 'mean' pass if out_fmt == 'xml': print(result.to_xml()) elif out_fmt == 'json': print(result.to_json()) else: # None or 'json' print('============================') print('Asset {asset_id}:'.format(asset_id=result.asset.asset_id)) print('============================') print(result) return 0
import numpy as np from vmaf import plt from vmaf.config import VmafConfig, DisplayConfig from vmaf.core.quality_runner import VmafossExecQualityRunner from vmaf.core.result_store import FileSystemResultStore from vmaf.core.train_test_model import RegressorMixin from vmaf.routine import run_test_on_dataset from vmaf.tools.decorator import persist_to_dir from vmaf.tools.misc import import_python_file __copyright__ = "Copyright 2016-2019, Netflix, Inc." __license__ = "Apache, Version 2.0" @persist_to_dir(VmafConfig.workdir_path("run_vmafossexec_subsampling")) def run_vmafossexec_with_subsample(dataset_filepath, subsample): result_store = FileSystemResultStore() runner_class = VmafossExecQualityRunner dataset = import_python_file(dataset_filepath) start_time = time() assets, results = run_test_on_dataset(dataset, runner_class, None, result_store, model_filepath=None, parallelize=False, fifo_mode=True,
class CornerCaseTest(unittest.TestCase): LOG_FILENAME = VmafConfig.workdir_path("logCornerCaseTest") CMD_TEMPLATE = """ {vmaf} vif {fmt} {ref} {dis} {w} {h} > {log}; {vmaf} adm {fmt} {ref} {dis} {w} {h} >> {log}; {vmaf} ansnr {fmt} {ref} {dis} {w} {h} >> {log}; {vmaf} motion {fmt} {ref} {dis} {w} {h} >> {log};""" def setUp(self): unittest.TestCase.setUp(self) if os.path.exists(self.LOG_FILENAME): os.remove(self.LOG_FILENAME) def tearDown(self): unittest.TestCase.tearDown(self) if os.path.exists(self.LOG_FILENAME): os.remove(self.LOG_FILENAME) if (REMOVE_LOG): (logPath, logFilePrefix) = os.path.split(self.LOG_FILENAME) filenames = [filename for filename in os.listdir(logPath) if filename.startswith(logFilePrefix)] for filename in filenames: os.remove(os.path.join(logPath, filename)) def test_checkerboard_identical(self): LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_checkerboardIdentical' ref_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv") dis_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv") yuv_fmt = "yuv420p" yuv_width = 1920 yuv_height = 1080 cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv, dis=dis_yuv, w=yuv_width, h=yuv_height, log=LOCAL_LOG_FILENAME) run_process(cmd, shell=True) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 1.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 21.1138813333, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.554836666666667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 12.554836666666667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 1.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 2773.891225, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 33021350.5, places=-3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 29.8567246667, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 25757432.0, places=-3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 259774.958333, places=1) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 277.120382, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 924.193766, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3) def test_checkerboard_shifted_by_1(self): LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_checkerboard_shifted_by_1' ref_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv") dis_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_1_0.yuv") yuv_fmt = "yuv420p" yuv_width = 1920 yuv_height = 1080 cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv, dis=dis_yuv, w=yuv_width, h=yuv_height, log=LOCAL_LOG_FILENAME) run_process(cmd, shell=True) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 0.7853383333333334, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 7.92623066667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.5548366667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 12.5548366667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 0.156834666667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 2178.5352886666665, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 5178894.51562, places=-1) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 16.669074, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 2908829.0, places=-1) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 128957.796875, places=-2) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 201.15329999999997, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 765.1562903333333, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3) def test_checkerboard_opposite(self): LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_checkerboard_opposite' ref_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv") dis_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_10_0.yuv") yuv_fmt = "yuv420p" yuv_width = 1920 yuv_height = 1080 cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv, dis=dis_yuv, w=yuv_width, h=yuv_height, log=LOCAL_LOG_FILENAME) run_process(cmd, shell=True) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 0.053996333333333334, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], -5.758091333333334, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.554836666666667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 12.554836666666667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 0.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 149.780313, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 6.66666666667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 2.984752, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 6.66666666667, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 0.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 65.573967, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 16.667711, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3) def test_flat_identical(self): LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_flat_identical' ref_yuv = VmafConfig.test_resource_path("yuv", "flat_1920_1080_0.yuv") dis_yuv = VmafConfig.test_resource_path("yuv", "flat_1920_1080_0.yuv") yuv_fmt = "yuv420p" yuv_width = 1920 yuv_height = 1080 cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv, dis=dis_yuv, w=yuv_width, h=yuv_height, log=LOCAL_LOG_FILENAME) run_process(cmd, shell=True) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 1.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 60.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 0.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 0.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 1.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 149.780392, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 149.780392, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 2754000.15625, places=1) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 2754000.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 60.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 2073600.125, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 2073600.000, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 32400.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 32400.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 65.573967, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 65.573967, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 16.667747, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 16.667747, places=3) def test_flat_value10(self): LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_flat_value10' ref_yuv = VmafConfig.test_resource_path("yuv", "flat_1920_1080_0.yuv") dis_yuv = VmafConfig.test_resource_path("yuv", "flat_1920_1080_10.yuv") yuv_fmt = "yuv420p" yuv_width = 1920 yuv_height = 1080 cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv, dis=dis_yuv, w=yuv_width, h=yuv_height, log=LOCAL_LOG_FILENAME) run_process(cmd, shell=True) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 1.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 21.899511, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 0.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 0.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 1.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 149.780313, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 149.780392, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 2753999.99219, places=1) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 2754000.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 29.045954, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0],2073600.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 2073600.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 32400.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 32400.0, places=4) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 65.573967, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 65.573967, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 16.667711, places=3) self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 16.667747, places=3)
num_train = 500 num_test = 50 n_epochs = 30 seed = 0 # None # read input dataset dataset_path = VmafConfig.resource_path('dataset', 'BSDS500_noisy_dataset.py') dataset = import_python_file(dataset_path) assets = read_dataset(dataset) # shuffle assets np.random.seed(seed) np.random.shuffle(assets) assets = assets[:(num_train + num_test)] raw_video_h5py_filepath = VmafConfig.workdir_path('rawvideo.hdf5') raw_video_h5py_file = DisYUVRawVideoExtractor.open_h5py_file( raw_video_h5py_filepath) print '======================== Extract raw YUVs ==============================' _, raw_yuvs = run_executors_in_parallel( DisYUVRawVideoExtractor, assets, fifo_mode=True, delete_workdir=True, parallelize=False, # CAN ONLY USE SERIAL MODE FOR DisYRawVideoExtractor result_store=None, optional_dict=None, optional_dict2={'h5py_file': raw_video_h5py_file})
def test_run_vmaf_fextractor_with_padding(self): # pad_cmd: iw+100:ih+100:50:50 - pad to (iw+100)x(ih+100), where iw is # input width, ih is input height, and starting point is (-50, -50) ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324, 'pad_cmd': 'iw+100:ih+100:50:50', 'quality_width': 676, 'quality_height': 424, }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324, 'pad_cmd': 'iw+100:ih+100:50:50', 'quality_width': 676, 'quality_height': 424, }) self.fextractor = VmafFeatureExtractor([asset, asset_original], None, fifo_mode=True) self.fextractor.run(parallelize=False) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.51023564583333325, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 2.6397702083333332, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'], 0.9410537302204777, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 26.893242291666667, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 2.6397702083333332, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 34.306043416666668, places=4)
def setUp(self): self.raw_dataset_filepath = VmafConfig.resource_path("dataset", "NFLX_dataset_public_raw.py") self.derived_dataset_path = VmafConfig.workdir_path("test_derived_dataset.py") self.derived_dataset_path_pyc = VmafConfig.workdir_path("test_derived_dataset.pyc")
def test_run_vmaf_fextractor_with_resampling(self): ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324, 'quality_width': 160, 'quality_height': 90 }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324, 'quality_width': 160, 'quality_height': 90 }) self.fextractor = VmafFeatureExtractor([asset, asset_original], None, fifo_mode=False) self.fextractor.run(parallelize=False) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.782546520833, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 1.3216766875, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_score'], 0.98229347916666665, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 28.0085990417, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 1.3216766875, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 31.811350125, places=4)
def main(): if len(sys.argv) < 6: print_usage() return 2 try: fmt = sys.argv[1] width = int(sys.argv[2]) height = int(sys.argv[3]) ref_path = sys.argv[4] dis_path = sys.argv[5] except ValueError: print_usage() return 2 if width < 0 or height < 0: print("width and height must be non-negative, but are {w} and {h}".format(w=width, h=height)) print_usage() return 2 if fmt not in FMTS: print_usage() return 2 out_fmt = get_cmd_option(sys.argv, 6, len(sys.argv), '--out-fmt') if not (out_fmt is None or out_fmt == 'xml' or out_fmt == 'json' or out_fmt == 'text'): print_usage() return 2 pool_method = get_cmd_option(sys.argv, 6, len(sys.argv), '--pool') if not (pool_method is None or pool_method in POOL_METHODS): print('--pool can only have option among {}'.format(', '.join(POOL_METHODS))) return 2 asset = Asset(dataset="cmd", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={'width':width, 'height':height, 'yuv_type':fmt} ) assets = [asset] runner_class = PsnrQualityRunner runner = runner_class( assets, None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=None, optional_dict2=None, ) # run runner.run() result = runner.results[0] # pooling if pool_method == 'harmonic_mean': result.set_score_aggregate_method(ListStats.harmonic_mean) elif pool_method == 'min': result.set_score_aggregate_method(np.min) elif pool_method == 'median': result.set_score_aggregate_method(np.median) elif pool_method == 'perc5': result.set_score_aggregate_method(ListStats.perc5) elif pool_method == 'perc10': result.set_score_aggregate_method(ListStats.perc10) elif pool_method == 'perc20': result.set_score_aggregate_method(ListStats.perc20) else: # None or 'mean' pass # output if out_fmt == 'xml': print(result.to_xml()) elif out_fmt == 'json': print(result.to_json()) else: # None or 'text' print(str(result)) return 0
def test_run_parallel_dis_y_fextractor(self): print( 'test on running dis YUV raw video extractor in parallel (disabled)...' ) ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324 }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324 }) h5py_file = DisYUVRawVideoExtractor.open_h5py_file(self.h5py_filepath) optional_dict2 = {'h5py_file': h5py_file} fextractor = DisYUVRawVideoExtractor([asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict={'channels': 'yu'}, optional_dict2=optional_dict2) self.fextractors = [fextractor] fextractor.run(parallelize=False ) # Can't run parallel: can't pickle FileID objects results = fextractor.results self.assertAlmostEqual(np.mean(results[0]['dis_y']), 61.332006579182384, places=4) self.assertAlmostEquals(np.mean(results[1]['dis_y']), 59.788567297525148, places=4) self.assertAlmostEqual(np.mean(results[0]['dis_u']), 115.23227407335962, places=4) self.assertAlmostEquals(np.mean(results[1]['dis_u']), 114.49701717535437, places=4) with self.assertRaises(KeyError): np.mean(results[0]['dis_v']) DisYUVRawVideoExtractor.close_h5py_file(h5py_file)
def read_dataset(dataset, **kwargs): groundtruth_key = kwargs[ 'groundtruth_key'] if 'groundtruth_key' in kwargs else None skip_asset_with_none_groundtruth = kwargs['skip_asset_with_none_groundtruth'] \ if 'skip_asset_with_none_groundtruth' in kwargs else False # asserts, can add more to the list... assert hasattr(dataset, 'dataset_name') assert hasattr(dataset, 'ref_videos') assert hasattr(dataset, 'dis_videos') assert hasattr(dataset, 'yuv_fmt') or all( ['yuv_fmt' in ref_video for ref_video in dataset.ref_videos]) data_set_name = dataset.dataset_name ref_videos = dataset.ref_videos dis_videos = dataset.dis_videos width = dataset.width if hasattr(dataset, 'width') else None height = dataset.height if hasattr(dataset, 'height') else None yuv_fmt = dataset.yuv_fmt if hasattr(dataset, 'yuv_fmt') else None quality_width = dataset.quality_width if hasattr(dataset, 'quality_width') else None quality_height = dataset.quality_height if hasattr( dataset, 'quality_height') else None resampling_type = dataset.resampling_type if hasattr( dataset, 'resampling_type') else None crop_cmd = dataset.crop_cmd if hasattr(dataset, 'crop_cmd') else None pad_cmd = dataset.pad_cmd if hasattr(dataset, 'pad_cmd') else None ref_dict = {} # dictionary of content_id -> path for ref videos for ref_video in ref_videos: ref_dict[ref_video['content_id']] = ref_video assets = [] for dis_video in dis_videos: if groundtruth_key is not None: groundtruth = dis_video[groundtruth_key] else: if 'dmos' in dis_video: groundtruth = dis_video['dmos'] elif 'mos' in dis_video: groundtruth = dis_video['mos'] elif 'groundtruth' in dis_video: groundtruth = dis_video['groundtruth'] else: groundtruth = None if 'os' in dis_video: raw_groundtruth = dis_video['os'] else: raw_groundtruth = None ref_video = ref_dict[dis_video['content_id']] ref_path = ref_video['path'] ref_yuv_fmt_ = yuv_fmt if yuv_fmt is not None else ref_dict[ dis_video['content_id']]['yuv_fmt'] dis_yuv_fmt_ = dis_video[ 'yuv_fmt'] if 'yuv_fmt' in dis_video else ref_yuv_fmt_ if width is not None: width_ = width elif 'width' in ref_video: width_ = ref_video[ 'width'] # NOTE: width in ref_video not dis_video else: width_ = None if height is not None: height_ = height elif 'height' in ref_video: height_ = ref_video[ 'height'] # NOTE: height in ref_video not dis_video else: height_ = None if quality_width is not None: quality_width_ = quality_width elif 'quality_width' in dis_video: quality_width_ = dis_video['quality_width'] else: quality_width_ = None if quality_height is not None: quality_height_ = quality_height elif 'quality_height' in dis_video: quality_height_ = dis_video['quality_height'] else: quality_height_ = None if resampling_type is not None: resampling_type_ = resampling_type elif 'resampling_type' in dis_video: resampling_type_ = dis_video['resampling_type'] else: resampling_type_ = None if crop_cmd is not None: crop_cmd_ = crop_cmd elif 'crop_cmd' in dis_video: crop_cmd_ = dis_video['crop_cmd'] else: crop_cmd_ = None if pad_cmd is not None: pad_cmd_ = pad_cmd elif 'pad_cmd' in dis_video: pad_cmd_ = dis_video['pad_cmd'] else: pad_cmd_ = None asset_dict = { 'ref_yuv_type': ref_yuv_fmt_, 'dis_yuv_type': dis_yuv_fmt_ } if width_ is not None: if asset_dict['ref_yuv_type'] != 'notyuv': asset_dict['ref_width'] = width_ if asset_dict['dis_yuv_type'] != 'notyuv': asset_dict['dis_width'] = width_ if height_ is not None: if asset_dict['ref_yuv_type'] != 'notyuv': asset_dict['ref_height'] = height_ if asset_dict['dis_yuv_type'] != 'notyuv': asset_dict['dis_height'] = height_ if groundtruth is not None: asset_dict['groundtruth'] = groundtruth if raw_groundtruth is not None: asset_dict['raw_groundtruth'] = raw_groundtruth if quality_width_ is not None: asset_dict['quality_width'] = quality_width_ if quality_height_ is not None: asset_dict['quality_height'] = quality_height_ if resampling_type_ is not None: asset_dict['resampling_type'] = resampling_type_ if crop_cmd_ is not None: asset_dict['crop_cmd'] = crop_cmd_ if pad_cmd_ is not None: asset_dict['pad_cmd'] = pad_cmd_ if groundtruth is None and skip_asset_with_none_groundtruth: pass else: asset = Asset( dataset=data_set_name, content_id=dis_video['content_id'], asset_id=dis_video['asset_id'], workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_video['path'], asset_dict=asset_dict, ) assets.append(asset) return assets
def main(): if len(sys.argv) < 2: print_usage() return 2 input_filepath = sys.argv[1] model_path = get_cmd_option(sys.argv, 2, len(sys.argv), '--model') out_fmt = get_cmd_option(sys.argv, 2, len(sys.argv), '--out-fmt') if not (out_fmt is None or out_fmt == 'xml' or out_fmt == 'json' or out_fmt == 'text'): print_usage() return 2 pool_method = get_cmd_option(sys.argv, 2, len(sys.argv), '--pool') if not (pool_method is None or pool_method in POOL_METHODS): print '--pool can only have option among {}'.format(', '.join(POOL_METHODS)) return 2 parallelize = cmd_option_exists(sys.argv, 2, len(sys.argv), '--parallelize') phone_model = cmd_option_exists(sys.argv, 2, len(sys.argv), '--phone-model') assets = [] line_idx = 0 with open(input_filepath, "rt") as input_file: for line in input_file.readlines(): # match comment mo = re.match(r"^#", line) if mo: print "Skip commented line: {}".format(line) continue # match whitespace mo = re.match(r"[\s]+", line) if mo: continue # example: yuv420p 576 324 ref.yuv dis.yuv mo = re.match(r"([\S]+) ([0-9]+) ([0-9]+) ([\S]+) ([\S]+)", line) if not mo or mo.group(1) not in FMTS: print "Unknown format: {}".format(line) print_usage() return 1 fmt = mo.group(1) width = int(mo.group(2)) height = int(mo.group(3)) ref_file = mo.group(4) dis_file = mo.group(5) asset = Asset(dataset="cmd", content_id=0, asset_id=line_idx, workdir_root=VmafConfig.workdir_path(), ref_path=ref_file, dis_path=dis_file, asset_dict={'width':width, 'height':height, 'yuv_type':fmt} ) assets.append(asset) line_idx += 1 runner_class = VmafQualityRunner if model_path is None: optional_dict = None else: optional_dict = {'model_filepath':model_path} if phone_model: if optional_dict is None: optional_dict = {} optional_dict['enable_transform_score'] = True runner = runner_class( assets, None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=optional_dict, optional_dict2=None, ) runner.run(parallelize=parallelize) results = runner.results # output for result in results: # pooling if pool_method == 'harmonic_mean': result.set_score_aggregate_method(ListStats.harmonic_mean) elif pool_method == 'min': result.set_score_aggregate_method(np.min) elif pool_method == 'median': result.set_score_aggregate_method(np.median) elif pool_method == 'perc5': result.set_score_aggregate_method(ListStats.perc5) elif pool_method == 'perc10': result.set_score_aggregate_method(ListStats.perc10) elif pool_method == 'perc20': result.set_score_aggregate_method(ListStats.perc20) else: # None or 'mean' pass if out_fmt == 'xml': print result.to_xml() elif out_fmt == 'json': print result.to_json() else: # None or 'json' print '============================' print 'Asset {asset_id}:'.format(asset_id=result.asset.asset_id) print '============================' print str(result) return 0
def main(): if len(sys.argv) < 5: print_usage() return 2 try: q_width = int(sys.argv[1]) q_height = int(sys.argv[2]) ref_file = sys.argv[3] dis_file = sys.argv[4] except ValueError: print_usage() return 2 if q_width < 0 or q_height < 0: print( "quality_width and quality_height must be non-negative, but are {w} and {h}" .format(w=q_width, h=q_height)) print_usage() return 2 model_path = get_cmd_option(sys.argv, 5, len(sys.argv), '--model') out_fmt = get_cmd_option(sys.argv, 5, len(sys.argv), '--out-fmt') if not (out_fmt is None or out_fmt == 'xml' or out_fmt == 'json' or out_fmt == 'text'): print_usage() return 2 ref_fmt = get_cmd_option(sys.argv, 5, len(sys.argv), '--ref-fmt') if not (ref_fmt is None or ref_fmt in FMTS): print('--ref-fmt can only have option among {}'.format( ', '.join(FMTS))) ref_width = get_cmd_option(sys.argv, 5, len(sys.argv), '--ref-width') ref_height = get_cmd_option(sys.argv, 5, len(sys.argv), '--ref-height') dis_width = get_cmd_option(sys.argv, 5, len(sys.argv), '--dis-width') dis_height = get_cmd_option(sys.argv, 5, len(sys.argv), '--dis-height') obj_file = get_cmd_option(sys.argv, 6, len(sys.argv), '--attention') dis_fmt = get_cmd_option(sys.argv, 5, len(sys.argv), '--dis-fmt') if not (dis_fmt is None or dis_fmt in FMTS): print('--dis-fmt can only have option among {}'.format( ', '.join(FMTS))) work_dir = get_cmd_option(sys.argv, 5, len(sys.argv), '--work-dir') pool_method = get_cmd_option(sys.argv, 5, len(sys.argv), '--pool') if not (pool_method is None or pool_method in POOL_METHODS): print('--pool can only have option among {}'.format( ', '.join(POOL_METHODS))) return 2 show_local_explanation = cmd_option_exists(sys.argv, 5, len(sys.argv), '--local-explain') phone_model = cmd_option_exists(sys.argv, 5, len(sys.argv), '--phone-model') enable_conf_interval = cmd_option_exists(sys.argv, 5, len(sys.argv), '--ci') save_plot_dir = get_cmd_option(sys.argv, 5, len(sys.argv), '--save-plot') if work_dir is None: work_dir = VmafConfig.workdir_path() asset_dict = {'quality_width': q_width, 'quality_height': q_height} if ref_fmt is None: asset_dict['ref_yuv_type'] = 'notyuv' else: if ref_width is None or ref_height is None: print( 'if --ref-fmt is specified, both --ref-width and --ref-height must be specified' ) return 2 else: asset_dict['ref_yuv_type'] = ref_fmt asset_dict['ref_width'] = ref_width asset_dict['ref_height'] = ref_height if dis_fmt is None: asset_dict['dis_yuv_type'] = 'notyuv' else: if dis_width is None or dis_height is None: print( 'if --dis-fmt is specified, both --dis-width and --dis-height must be specified' ) return 2 else: asset_dict['dis_yuv_type'] = dis_fmt asset_dict['dis_width'] = dis_width asset_dict['dis_height'] = dis_height if show_local_explanation and enable_conf_interval: print('cannot set both --local-explain and --ci flags') return 2 asset = Asset( dataset="cmd", content_id=abs(hash(get_file_name_without_extension(ref_file))) % (10**16), asset_id=abs(hash(get_file_name_without_extension(ref_file))) % (10**16), workdir_root=work_dir, ref_path=ref_file, dis_path=dis_file, obj_path=obj_file, asset_dict=asset_dict, ) assets = [asset] if show_local_explanation: from vmaf.core.quality_runner_extra import VmafQualityRunnerWithLocalExplainer runner_class = VmafQualityRunnerWithLocalExplainer elif enable_conf_interval: from vmaf.core.quality_runner import BootstrapVmafQualityRunner runner_class = BootstrapVmafQualityRunner else: runner_class = VmafQualityRunner if model_path is None: optional_dict = None else: optional_dict = {'model_filepath': model_path} if phone_model: if optional_dict is None: optional_dict = {} optional_dict['enable_transform_score'] = True runner = runner_class( assets, None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=optional_dict, optional_dict2=None, ) # run runner.run() result = runner.results[0] # pooling if pool_method == 'harmonic_mean': result.set_score_aggregate_method(ListStats.harmonic_mean) elif pool_method == 'min': result.set_score_aggregate_method(np.min) elif pool_method == 'median': result.set_score_aggregate_method(np.median) elif pool_method == 'perc5': result.set_score_aggregate_method(ListStats.perc5) elif pool_method == 'perc10': result.set_score_aggregate_method(ListStats.perc10) elif pool_method == 'perc20': result.set_score_aggregate_method(ListStats.perc20) else: # None or 'mean' pass # output if out_fmt == 'xml': print(result.to_xml()) elif out_fmt == 'json': print(result.to_json()) else: # None or 'text' print(str(result)) # local explanation if show_local_explanation: runner.show_local_explanations([result]) if save_plot_dir is None: DisplayConfig.show() else: DisplayConfig.show(write_to_dir=save_plot_dir) return 0
def test_run_vmafrc_runner_yuv420p10le_sparks(self): ref_path = VmafConfig.test_resource_path( "yuv", "sparks_ref_480x270.yuv42010le.yuv") dis_path = VmafConfig.test_resource_path( "yuv", "sparks_dis_480x270.yuv42010le.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 480, 'height': 270, 'yuv_type': 'yuv420p10le' }) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 480, 'height': 270, 'yuv_type': 'yuv420p10le' }) self.runner = VmafrcQualityRunner([asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict={ 'float_psnr': True, 'float_ssim': True, 'float_ms_ssim': True, }) self.runner.run(parallelize=True) results = self.runner.results self.assertAlmostEqual(results[0]['VMAFRC_vif_scale0_score'], 0.9240746, places=4) self.assertAlmostEqual(results[0]['VMAFRC_vif_scale1_score'], 0.9968371999999999, places=4) self.assertAlmostEqual(results[0]['VMAFRC_vif_scale2_score'], 0.9987575999999999, places=4) self.assertAlmostEqual(results[0]['VMAFRC_vif_scale3_score'], 0.9993221999999999, places=4) self.assertAlmostEqual(results[0]['VMAFRC_motion2_score'], 0.7523685999999999, places=4) self.assertAlmostEqual(results[0]['VMAFRC_adm2_score'], 0.9981770000000001, places=4) self.assertAlmostEqual(results[0]['VMAFRC_float_psnr_score'], 48.81622, places=4) self.assertAlmostEqual(results[0]['VMAFRC_float_ssim_score'], 0.99566, places=4) self.assertAlmostEqual(results[0]['VMAFRC_float_ms_ssim_score'], 0.9993778000000001, places=4) self.assertAlmostEqual(results[1]['VMAFRC_vif_scale0_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAFRC_vif_scale1_score'], 0.9999990000000001, places=4) self.assertAlmostEqual(results[1]['VMAFRC_vif_scale2_score'], 0.9999990000000001, places=4) self.assertAlmostEqual(results[1]['VMAFRC_vif_scale3_score'], 0.9999990000000001, places=4) self.assertAlmostEqual(results[1]['VMAFRC_motion2_score'], 0.7523685999999999, places=4) self.assertAlmostEqual(results[1]['VMAFRC_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAFRC_float_psnr_score'], 72.0, places=4) self.assertAlmostEqual(results[1]['VMAFRC_float_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAFRC_float_ms_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['VMAFRC_score'], 97.90585999999999, places=4) self.assertAlmostEqual(results[1]['VMAFRC_score'], 98.47138, places=4)
def test_run_strred_fextractor_blackframes(self): ref_path = VmafConfig.test_resource_path("yuv", "flat_1920_1080_0.yuv") dis_path = VmafConfig.test_resource_path("yuv", "flat_1920_1080_10.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324 }) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324 }) from vmaf.core.result_store import FileSystemResultStore result_store = FileSystemResultStore(logger=None) self.fextractor = StrredFeatureExtractor([asset, asset_original], None, fifo_mode=True, result_store=result_store) self.fextractor.run(parallelize=True) result0, result1 = self.fextractor.results import os self.assertTrue( os.path.exists(result_store._get_result_file_path(result0))) self.assertTrue( os.path.exists(result_store._get_result_file_path(result1))) self.fextractor.run(parallelize=True) results = self.fextractor.results # ignore NaN for result in results: result.set_score_aggregate_method(ListStats.nonemean) self.assertAlmostEqual(results[0]['STRRED_feature_srred_score'], 1220.5679849999999, places=4) self.assertAlmostEqual(results[0]['STRRED_feature_trred_score'], 50983.3097155, places=4) self.assertAlmostEqual(results[0]['STRRED_feature_strred_score'], 62228595.6081, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_srred_score'], 0.0, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_trred_score'], 0.0, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_strred_score'], 0.0, places=4)
def setUp(self): self.dataset_filepath = VmafConfig.test_resource_path('NFLX_dataset_public_raw.py') self.output_dataset_filepath = VmafConfig.workdir_path('NFLX_dataset_public_test.py') self.output_dataset_pyc_filepath = VmafConfig.workdir_path('NFLX_dataset_public_test.pyc')
def test_run_vmaf_fextractor_with_resampling(self): ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324, 'quality_width': 160, 'quality_height': 90 }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324, 'quality_width': 160, 'quality_height': 90 }) self.fextractor = VmafFeatureExtractor([asset, asset_original], None, fifo_mode=False) self.fextractor.run(parallelize=False) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.74165043750000004, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 1.4066421666666666, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm_score'], 0.9807496875, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 27.319241250000001, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 1.4066421666666666, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 30.682829895833333, places=4)
def main(): if len(sys.argv) < 5: print_usage() return 2 try: q_width = int(sys.argv[1]) q_height = int(sys.argv[2]) ref_file = sys.argv[3] dis_file = sys.argv[4] except ValueError: print_usage() return 2 if q_width < 0 or q_height < 0: print "quality_width and quality_height must be non-negative, but are {w} and {h}".format(w=q_width, h=q_height) print_usage() return 2 model_path = get_cmd_option(sys.argv, 5, len(sys.argv), '--model') out_fmt = get_cmd_option(sys.argv, 5, len(sys.argv), '--out-fmt') if not (out_fmt is None or out_fmt == 'xml' or out_fmt == 'json' or out_fmt == 'text'): print_usage() return 2 work_dir = get_cmd_option(sys.argv, 5, len(sys.argv), '--work-dir') pool_method = get_cmd_option(sys.argv, 5, len(sys.argv), '--pool') if not (pool_method is None or pool_method in POOL_METHODS): print '--pool can only have option among {}'.format(', '.join(POOL_METHODS)) return 2 show_local_explanation = cmd_option_exists(sys.argv, 5, len(sys.argv), '--local-explain') phone_model = cmd_option_exists(sys.argv, 5, len(sys.argv), '--phone-model') if work_dir is None: work_dir = VmafConfig.workdir_path() asset = Asset(dataset="cmd", content_id=abs(hash(get_file_name_without_extension(ref_file))) % (10 ** 16), asset_id=abs(hash(get_file_name_without_extension(ref_file))) % (10 ** 16), workdir_root=work_dir, ref_path=ref_file, dis_path=dis_file, asset_dict={'quality_width':q_width, 'quality_height':q_height, 'yuv_type': 'notyuv'} ) assets = [asset] if not show_local_explanation: runner_class = VmafQualityRunner else: runner_class = VmafQualityRunnerWithLocalExplainer if model_path is None: optional_dict = None else: optional_dict = {'model_filepath':model_path} if phone_model: if optional_dict is None: optional_dict = {} optional_dict['enable_transform_score'] = True runner = runner_class( assets, None, fifo_mode=True, delete_workdir=True, result_store=None, optional_dict=optional_dict, optional_dict2=None, ) # run runner.run() result = runner.results[0] # pooling if pool_method == 'harmonic_mean': result.set_score_aggregate_method(ListStats.harmonic_mean) elif pool_method == 'min': result.set_score_aggregate_method(np.min) elif pool_method == 'median': result.set_score_aggregate_method(np.median) elif pool_method == 'perc5': result.set_score_aggregate_method(ListStats.perc5) elif pool_method == 'perc10': result.set_score_aggregate_method(ListStats.perc10) elif pool_method == 'perc20': result.set_score_aggregate_method(ListStats.perc20) else: # None or 'mean' pass # output if out_fmt == 'xml': print result.to_xml() elif out_fmt == 'json': print result.to_json() else: # None or 'text' print str(result) # local explanation if show_local_explanation: import matplotlib.pyplot as plt runner.show_local_explanations([result]) plt.show() return 0
def test_run_vmaf_fextractor_with_cropping(self): # crop_cmd: 288:162:144:81 - crop to 288x162 with upper-left pixel # starting at coordinate (144, 81) ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324, 'crop_cmd': '288:162:144:81', 'quality_width': 288, 'quality_height': 162, }) asset_original = Asset(dataset="test", content_id=0, asset_id=2, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324, 'crop_cmd': '288:162:144:81', 'quality_width': 288, 'quality_height': 162, }) self.fextractor = VmafFeatureExtractor([asset, asset_original], None, fifo_mode=False) self.fextractor.run(parallelize=False) results = self.fextractor.results self.assertAlmostEqual(results[0]['VMAF_feature_vif_score'], 0.45365762500000012, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_motion_score'], 2.8779373333333331, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_adm2_score'], 0.9388824973398119, places=4) self.assertAlmostEqual(results[0]['VMAF_feature_ansnr_score'], 23.942050354166668, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_vif_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_motion_score'], 2.8779373333333331, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['VMAF_feature_ansnr_score'], 31.71648420833333, places=4)
def test_run_testlib_runner(self): print 'test on running TESTLIB runner...' ref_path = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv") dis_path = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324 }) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324 }) self.runner = TestLibRunner( [asset, asset_original], None, fifo_mode=True, delete_workdir=True, result_store=None, ) self.runner.run() results = self.runner.results self.assertAlmostEqual(results[0]['TESTLIB_vif_scale0_score'], 0.363420458333, places=4) self.assertAlmostEqual(results[0]['TESTLIB_vif_scale1_score'], 0.766647520833, places=4) self.assertAlmostEqual(results[0]['TESTLIB_vif_scale2_score'], 0.862854708333, places=4) self.assertAlmostEqual(results[0]['TESTLIB_vif_scale3_score'], 0.915971791667, places=4) self.assertAlmostEqual(results[0]['TESTLIB_motion2_score'], 3.8953518541666665, places=4) self.assertAlmostEqual(results[0]['TESTLIB_adm2_score'], 0.93458777083333333, places=4) self.assertAlmostEqual(results[0]['TESTLIB_psnr_score'], 30.7550666667, places=4) self.assertAlmostEqual(results[0]['TESTLIB_ssim_score'], 0.86322654166666657, places=4) self.assertAlmostEqual(results[0]['TESTLIB_ms_ssim_score'], 0.9632498125, places=4) self.assertAlmostEqual(results[1]['TESTLIB_vif_scale0_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['TESTLIB_vif_scale1_score'], 0.999999958333, places=4) self.assertAlmostEqual(results[1]['TESTLIB_vif_scale2_score'], 0.999999416667, places=4) self.assertAlmostEqual(results[1]['TESTLIB_vif_scale3_score'], 0.999999208333, places=4) self.assertAlmostEqual(results[1]['TESTLIB_motion2_score'], 3.8953518541666665, places=4) self.assertAlmostEqual(results[1]['TESTLIB_adm2_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['TESTLIB_psnr_score'], 60.0, places=4) self.assertAlmostEqual(results[1]['TESTLIB_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[1]['TESTLIB_ms_ssim_score'], 1.0, places=4) self.assertAlmostEqual(results[0]['TESTLIB_score'], 76.699271272486044, places=3) self.assertAlmostEqual(results[1]['TESTLIB_score'], 99.946416604585025, places=4)
class FeatureTestYuv422p10le(unittest.TestCase): LOG_FILENAME = VmafConfig.workdir_path("logFeatureTestYuv422p10le") REF_YUV = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv422p10le.yuv") DIS_YUV = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv422p10le.yuv") YUV_FMT = "yuv422p10le" YUV_WIDTH = 576 YUV_HEIGHT = 324 def setUp(self): if os.path.exists(self.LOG_FILENAME): os.remove(self.LOG_FILENAME) def tearDown(self): if os.path.exists(self.LOG_FILENAME): os.remove(self.LOG_FILENAME) if (REMOVE_LOG): (logPath, logFilePrefix) = os.path.split(self.LOG_FILENAME) filenames = [filename for filename in os.listdir(logPath) if filename.startswith(logFilePrefix)] for filename in filenames: os.remove(os.path.join(logPath, filename)) def test_adm(self): ADM_LOG = self.LOG_FILENAME + '_adm' cmd = "{vmaf} adm {fmt} {ref} {dis} {w} {h} > {log}".format( vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=ADM_LOG ) run_process(cmd, shell=True) score, scores = read_log(ADM_LOG, "adm") self.assertAlmostEqual(score, 0.9345877708333336, places=4) score, scores = read_log(ADM_LOG, "adm_num") self.assertAlmostEqual(score, 371.8354140624999, places=4) score, scores = read_log(ADM_LOG, "adm_den") self.assertAlmostEqual(score, 397.8337897291667, places=4) score, scores = read_log(ADM_LOG, "adm_den_scale0") self.assertAlmostEqual(score, 50.143851375000004, places=4) score, scores = read_log(ADM_LOG, "adm_num_scale1") self.assertAlmostEqual(score, 66.58064533333334, places=4) score, scores = read_log(ADM_LOG, "adm_den_scale1") self.assertAlmostEqual(score, 74.47438285416666, places=4) score, scores = read_log(ADM_LOG, "adm_num_scale2") self.assertAlmostEqual(score, 105.56477879166668, places=4) score, scores = read_log(ADM_LOG, "adm_den_scale2") self.assertAlmostEqual(score, 113.49725852083333, places=4) score, scores = read_log(ADM_LOG, "adm_num_scale3") self.assertAlmostEqual(score, 154.16224066666666, places=4) score, scores = read_log(ADM_LOG, "adm_den_scale3") self.assertAlmostEqual(score, 159.71829710416668, places=4) def test_ansnr(self): ANSNR_LOG = self. LOG_FILENAME + '_ansnr' cmd = "{vmaf} ansnr {fmt} {ref} {dis} {w} {h} > {log}".format( vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=ANSNR_LOG ) run_process(cmd, shell=True) score, scores = read_log(ANSNR_LOG, "ansnr") self.assertAlmostEqual(score, 23.5095715208, places=4) score, scores = read_log(ANSNR_LOG, "anpsnr") self.assertAlmostEqual(score, 34.1902860625, places=4) def test_motion(self): MOTION_LOG = self.LOG_FILENAME + '_motion' cmd = "{vmaf} motion {fmt} {ref} {dis} {w} {h} > {log}".format( vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=MOTION_LOG ) run_process(cmd, shell=True) score, scores = read_log(MOTION_LOG, "motion") self.assertAlmostEqual(score, 4.04982535417, places=4) def test_motion2(self): MOTION_LOG = self.LOG_FILENAME + '_motion2' cmd = "{vmaf} motion {fmt} {ref} {dis} {w} {h} > {log}".format( vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=MOTION_LOG ) run_process(cmd, shell=True) score, scores = read_log(MOTION_LOG, "motion2") self.assertAlmostEqual(score, 3.8953518541666665, places=4) def test_vif(self): VIF_LOG = self.LOG_FILENAME + '_vif' cmd = "{vmaf} vif {fmt} {ref} {dis} {w} {h} > {log}".format( vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=VIF_LOG ) run_process(cmd, shell=True) score, scores = read_log(VIF_LOG, "vif") self.assertAlmostEqual(score, 0.4460930625, places=4) self.assertAlmostEqual(scores[0], 0.580304, places=4) self.assertAlmostEqual(scores[1], 0.492477, places=4) score, scores = read_log(VIF_LOG, "vif_num") self.assertAlmostEqual(score, 712650.023478, places=0) score, scores = read_log(VIF_LOG, "vif_den") self.assertAlmostEqual(score, 1597314.95249, places=0) score, scores = read_log(VIF_LOG, "vif_num_scale0") self.assertAlmostEqual(score, 468101.509766, places=0) score, scores = read_log(VIF_LOG, "vif_num_scale1") self.assertAlmostEqual(score, 184971.572266, places=1) score, scores = read_log(VIF_LOG, "vif_num_scale2") self.assertAlmostEqual(score, 47588.8323567, places=0) score, scores = read_log(VIF_LOG, "vif_num_scale3") self.assertAlmostEqual(score, 11988.1090902, places=1) score, scores = read_log(VIF_LOG, "vif_den_scale0") self.assertAlmostEqual(score, 1287822.80208, places=0) score, scores = read_log(VIF_LOG, "vif_den_scale1") self.assertAlmostEqual(score, 241255.067708, places=1) score, scores = read_log(VIF_LOG, "vif_den_scale2") self.assertAlmostEqual(score, 55149.8169759, places=2) score, scores = read_log(VIF_LOG, "vif_den_scale3") self.assertAlmostEqual(score, 13087.2657267, places=2) def test_all(self): ALL_LOG = self.LOG_FILENAME + "_all" cmd = "{vmaf} all {fmt} {ref} {dis} {w} {h} > {log}".format( vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=ALL_LOG ) run_process(cmd, shell=True) score, scores = read_log(ALL_LOG, "vif") self.assertAlmostEqual(score, 0.4460930625, places=4) score, scores = read_log(ALL_LOG, "motion") self.assertAlmostEqual(score, 4.04982535417, places=4) score, scores = read_log(ALL_LOG, "motion2") self.assertAlmostEqual(score, 3.8953518541666665, places=4) score, scores = read_log(ALL_LOG, "ansnr") self.assertAlmostEqual(score, 23.5095715208, places=4) score, scores = read_log(ALL_LOG, "adm") self.assertAlmostEqual(score, 0.9345877708333336, places=4) score, scores = read_log(ALL_LOG, "adm_num") self.assertAlmostEqual(score, 371.8354140624999, places=4) score, scores = read_log(ALL_LOG, "adm_den") self.assertAlmostEqual(score, 397.8337897291667, places=4) score, scores = read_log(ALL_LOG, "vif_num") self.assertAlmostEqual(score, 712650.023478, places=0) score, scores = read_log(ALL_LOG, "vif_den") self.assertAlmostEqual(score, 1597314.95249, places=0) score, scores = read_log(ALL_LOG, "anpsnr") self.assertAlmostEqual(score, 34.1902860625, places=4) score, scores = read_log(ALL_LOG, "vif_num_scale0") self.assertAlmostEqual(score, 468101.509766, places=0) score, scores = read_log(ALL_LOG, "vif_num_scale1") self.assertAlmostEqual(score, 184971.572266, places=1) score, scores = read_log(ALL_LOG, "vif_num_scale2") self.assertAlmostEqual(score, 47588.8323567, places=0) score, scores = read_log(ALL_LOG, "vif_num_scale3") self.assertAlmostEqual(score, 11988.1090902, places=1) score, scores = read_log(ALL_LOG, "vif_den_scale0") self.assertAlmostEqual(score, 1287822.80208, places=0) score, scores = read_log(ALL_LOG, "vif_den_scale1") self.assertAlmostEqual(score, 241255.067708, places=1) score, scores = read_log(ALL_LOG, "vif_den_scale2") self.assertAlmostEqual(score, 55149.8169759, places=2) score, scores = read_log(ALL_LOG, "vif_den_scale3") self.assertAlmostEqual(score, 13087.2657267, places=2) score, scores = read_log(ALL_LOG, "adm_den_scale0") self.assertAlmostEqual(score, 50.143851375000004, places=4) score, scores = read_log(ALL_LOG, "adm_num_scale1") self.assertAlmostEqual(score, 66.58064533333334, places=4) score, scores = read_log(ALL_LOG, "adm_den_scale1") self.assertAlmostEqual(score, 74.47438285416666, places=4) score, scores = read_log(ALL_LOG, "adm_num_scale2") self.assertAlmostEqual(score, 105.56477879166668, places=4) score, scores = read_log(ALL_LOG, "adm_den_scale2") self.assertAlmostEqual(score, 113.49725852083333, places=4) score, scores = read_log(ALL_LOG, "adm_num_scale3") self.assertAlmostEqual(score, 154.16224066666666, places=4) score, scores = read_log(ALL_LOG, "adm_den_scale3") self.assertAlmostEqual(score, 159.71829710416668, places=4) def test_psnr(self): PSNR_LOG = self.LOG_FILENAME + '_psnr' cmd = "{psnr} {fmt} {ref} {dis} {w} {h} > {log}".format( psnr=required(ExternalProgram.psnr), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=PSNR_LOG ) run_process(cmd, shell=True) score, scores = read_log(PSNR_LOG, "psnr") self.assertAlmostEqual(score, 30.7805732917, places=4) self.assertAlmostEqual(scores[0], 34.786288, places=4) self.assertAlmostEqual(scores[1], 31.908737, places=4) def test_ssim(self): SSIM_LOG = self.LOG_FILENAME + '_ssim' cmd = "{ssim} {fmt} {ref} {dis} {w} {h} > {log}".format( ssim=required(ExternalProgram.ssim), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=SSIM_LOG ) run_process(cmd, shell=True) score, scores = read_log(SSIM_LOG, "ssim") self.assertAlmostEqual(score, 0.863226541666667, places=4) self.assertAlmostEqual(scores[0], 0.925023, places=4) self.assertAlmostEqual(scores[1], 0.891992, places=4) score, scores = read_log(SSIM_LOG, "ssim_l") self.assertAlmostEqual(score,0.998147458333333, places=4) self.assertAlmostEqual(scores[0], 0.999524, places=4) self.assertAlmostEqual(scores[1], 0.998983, places=4) score, scores = read_log(SSIM_LOG, "ssim_c") self.assertAlmostEqual(score, 0.9612679375000001, places=4) self.assertAlmostEqual(scores[0], 0.979614, places=4) self.assertAlmostEqual(scores[1], 0.96981, places=4) score, scores = read_log(SSIM_LOG, "ssim_s") self.assertAlmostEqual(score, 0.8977363333333335, places=4) self.assertAlmostEqual(scores[0], 0.943966, places=4) self.assertAlmostEqual(scores[1], 0.919507, places=4) def test_ms_ssim(self): MS_SSIM_LOG = self.LOG_FILENAME + '_msssim' cmd = "{ms_ssim} {fmt} {ref} {dis} {w} {h} > {log}".format( ms_ssim=required(ExternalProgram.ms_ssim), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV, w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=MS_SSIM_LOG ) run_process(cmd, shell=True) score, scores = read_log(MS_SSIM_LOG, "ms_ssim") self.assertAlmostEqual(score, 0.9632498125, places=4) self.assertAlmostEqual(scores[0], 0.981968, places=4) self.assertAlmostEqual(scores[1], 0.973366, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale0") self.assertAlmostEqual(score, 0.998147458333333, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale0") self.assertAlmostEqual(score, 0.9612679375000001, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale0") self.assertAlmostEqual(score, 0.8977363333333335, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale1") self.assertAlmostEqual(score, 0.9989961250000002, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale1") self.assertAlmostEqual(score, 0.9857694375, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale1") self.assertAlmostEqual(score, 0.941185875, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale2") self.assertAlmostEqual(score, 0.9992356458333332, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale2") self.assertAlmostEqual(score, 0.997034020833, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale2") self.assertAlmostEqual(score, 0.977992145833, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale3") self.assertAlmostEqual(score, 0.9992921041666665, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale3") self.assertAlmostEqual(score, 0.9995884375000003, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale3") self.assertAlmostEqual(score, 0.9938712499999998, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale4") self.assertAlmostEqual(score, 0.9994035625000003, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale4") self.assertAlmostEqual(score, 0.999907625, places=4) score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale4") self.assertAlmostEqual(score,0.998222583333, places=4)
def read_dataset(dataset, **kwargs): groundtruth_key = kwargs[ 'groundtruth_key'] if 'groundtruth_key' in kwargs else None skip_asset_with_none_groundtruth = kwargs['skip_asset_with_none_groundtruth'] \ if 'skip_asset_with_none_groundtruth' in kwargs else False content_ids = kwargs['content_ids'] if 'content_ids' in kwargs else None asset_ids = kwargs['asset_ids'] if 'asset_ids' in kwargs else None workdir_root = kwargs[ 'workdir_root'] if 'workdir_root' in kwargs else VmafConfig.workdir_path( ) # asserts, can add more to the list... assert hasattr(dataset, 'dataset_name') assert hasattr(dataset, 'ref_videos') assert hasattr(dataset, 'dis_videos') assert hasattr(dataset, 'yuv_fmt') or all( ['yuv_fmt' in ref_video for ref_video in dataset.ref_videos]) data_set_name = dataset.dataset_name ref_videos = dataset.ref_videos dis_videos = dataset.dis_videos width = dataset.width if hasattr(dataset, 'width') else None height = dataset.height if hasattr(dataset, 'height') else None yuv_fmt = dataset.yuv_fmt if hasattr(dataset, 'yuv_fmt') else None quality_width = dataset.quality_width if hasattr(dataset, 'quality_width') else None quality_height = dataset.quality_height if hasattr( dataset, 'quality_height') else None resampling_type = dataset.resampling_type if hasattr( dataset, 'resampling_type') else None crop_cmd = dataset.crop_cmd if hasattr(dataset, 'crop_cmd') else None pad_cmd = dataset.pad_cmd if hasattr(dataset, 'pad_cmd') else None workfile_yuv_type = dataset.workfile_yuv_type if hasattr( dataset, 'workfile_yuv_type') else None duration_sec = dataset.duration_sec if hasattr(dataset, 'duration_sec') else None fps = dataset.fps if hasattr(dataset, 'fps') else None start_frame = dataset.start_frame if hasattr(dataset, 'start_frame') else None end_frame = dataset.end_frame if hasattr(dataset, 'end_frame') else None ref_dict = {} # dictionary of content_id -> path for ref videos for ref_video in ref_videos: ref_dict[ref_video['content_id']] = ref_video assets = [] for dis_video in dis_videos: if content_ids is not None and dis_video[ 'content_id'] not in content_ids: continue if asset_ids is not None and dis_video['asset_id'] not in asset_ids: continue if groundtruth_key is not None: groundtruth = dis_video[groundtruth_key] else: if 'dmos' in dis_video: groundtruth = dis_video['dmos'] elif 'mos' in dis_video: groundtruth = dis_video['mos'] elif 'groundtruth' in dis_video: groundtruth = dis_video['groundtruth'] else: groundtruth = None if 'os' in dis_video: raw_groundtruth = dis_video['os'] else: raw_groundtruth = None if 'groundtruth_std' in dis_video: groundtruth_std = dis_video['groundtruth_std'] else: groundtruth_std = None if 'rebuf_indices' in dis_video: rebuf_indices = dis_video['rebuf_indices'] else: rebuf_indices = None ref_video = ref_dict[dis_video['content_id']] ref_path = ref_video['path'] ref_yuv_fmt_ = yuv_fmt if yuv_fmt is not None else ref_dict[ dis_video['content_id']]['yuv_fmt'] dis_yuv_fmt_ = dis_video[ 'yuv_fmt'] if 'yuv_fmt' in dis_video else ref_yuv_fmt_ if width is not None: width_ = width elif 'width' in ref_video and 'width' not in dis_video: width_ = ref_video['width'] elif 'width' in dis_video and 'width' not in ref_video: width_ = dis_video['width'] elif 'width' in ref_video and 'width' in dis_video: assert ref_video['width'] == dis_video['width'] width_ = ref_video['width'] else: width_ = None if height is not None: height_ = height elif 'height' in ref_video and 'height' not in dis_video: height_ = ref_video['height'] elif 'height' in dis_video and 'height' not in ref_video: height_ = dis_video['height'] elif 'height' in ref_video and 'height' in dis_video: assert ref_video['height'] == dis_video['height'] height_ = ref_video['height'] else: height_ = None if quality_width is not None: quality_width_ = quality_width elif 'quality_width' in dis_video: quality_width_ = dis_video['quality_width'] else: quality_width_ = None if quality_height is not None: quality_height_ = quality_height elif 'quality_height' in dis_video: quality_height_ = dis_video['quality_height'] else: quality_height_ = None if resampling_type is not None: resampling_type_ = resampling_type elif 'resampling_type' in dis_video: resampling_type_ = dis_video['resampling_type'] else: resampling_type_ = None if crop_cmd is not None: ref_crop_cmd_ = crop_cmd dis_crop_cmd_ = crop_cmd else: if 'crop_cmd' in ref_video: ref_crop_cmd_ = ref_video['crop_cmd'] else: ref_crop_cmd_ = None if 'crop_cmd' in dis_video: dis_crop_cmd_ = dis_video['crop_cmd'] else: dis_crop_cmd_ = None if pad_cmd is not None: ref_pad_cmd_ = pad_cmd dis_pad_cmd_ = pad_cmd else: if 'pad_cmd' in ref_video: ref_pad_cmd_ = ref_video['pad_cmd'] else: ref_pad_cmd_ = None if 'pad_cmd' in dis_video: dis_pad_cmd_ = dis_video['pad_cmd'] else: dis_pad_cmd_ = None if duration_sec is not None: duration_sec_ = duration_sec elif 'duration_sec' in dis_video: duration_sec_ = dis_video['duration_sec'] else: duration_sec_ = None if fps is not None: fps_ = fps elif 'fps' in dis_video: fps_ = dis_video['fps'] else: fps_ = None if start_frame is not None: start_frame_ = start_frame elif 'start_frame' in dis_video: start_frame_ = dis_video['start_frame'] else: start_frame_ = None if end_frame is not None: end_frame_ = end_frame elif 'end_frame' in dis_video: end_frame_ = dis_video['end_frame'] else: end_frame_ = None asset_dict = { 'ref_yuv_type': ref_yuv_fmt_, 'dis_yuv_type': dis_yuv_fmt_ } if width_ is not None: if asset_dict['ref_yuv_type'] != 'notyuv': asset_dict['ref_width'] = width_ if asset_dict['dis_yuv_type'] != 'notyuv': asset_dict['dis_width'] = width_ if height_ is not None: if asset_dict['ref_yuv_type'] != 'notyuv': asset_dict['ref_height'] = height_ if asset_dict['dis_yuv_type'] != 'notyuv': asset_dict['dis_height'] = height_ if groundtruth is not None: asset_dict['groundtruth'] = groundtruth if raw_groundtruth is not None: asset_dict['raw_groundtruth'] = raw_groundtruth if groundtruth_std is not None: asset_dict['groundtruth_std'] = groundtruth_std if quality_width_ is not None: asset_dict['quality_width'] = quality_width_ if quality_height_ is not None: asset_dict['quality_height'] = quality_height_ if resampling_type_ is not None: asset_dict['resampling_type'] = resampling_type_ if ref_crop_cmd_ is not None: asset_dict['ref_crop_cmd'] = ref_crop_cmd_ if dis_crop_cmd_ is not None: asset_dict['dis_crop_cmd'] = dis_crop_cmd_ if ref_pad_cmd_ is not None: asset_dict['ref_pad_cmd'] = ref_pad_cmd_ if dis_pad_cmd_ is not None: asset_dict['dis_pad_cmd'] = dis_pad_cmd_ if duration_sec_ is not None: asset_dict['duration_sec'] = duration_sec_ if workfile_yuv_type is not None: asset_dict['workfile_yuv_type'] = workfile_yuv_type if rebuf_indices is not None: asset_dict['rebuf_indices'] = rebuf_indices if fps_ is not None: asset_dict['fps'] = fps_ if start_frame_ is not None: asset_dict['start_frame'] = start_frame_ if end_frame_ is not None: asset_dict['end_frame'] = end_frame_ if groundtruth is None and skip_asset_with_none_groundtruth: pass else: asset = Asset( dataset=data_set_name, content_id=dis_video['content_id'], asset_id=dis_video['asset_id'], workdir_root=workdir_root, ref_path=ref_path, dis_path=dis_video['path'], asset_dict=asset_dict, ) assets.append(asset) return assets
def test_run_strred_fextractor_blackframes(self): print 'test on running STRRED feature extractor on flat frames...' ref_path = VmafConfig.test_resource_path("yuv", "flat_1920_1080_0.yuv") dis_path = VmafConfig.test_resource_path("yuv", "flat_1920_1080_10.yuv") asset = Asset(dataset="test", content_id=0, asset_id=0, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=dis_path, asset_dict={ 'width': 576, 'height': 324 }) asset_original = Asset(dataset="test", content_id=0, asset_id=1, workdir_root=VmafConfig.workdir_path(), ref_path=ref_path, dis_path=ref_path, asset_dict={ 'width': 576, 'height': 324 }) from vmaf.core.result_store import FileSystemResultStore result_store = FileSystemResultStore(logger=None) self.fextractor = StrredFeatureExtractor([asset, asset_original], None, fifo_mode=True, result_store=result_store) print ' running for the first time with fresh calculation...' self.fextractor.run(parallelize=True) result0, result1 = self.fextractor.results import os self.assertTrue( os.path.exists(result_store._get_result_file_path(result0))) self.assertTrue( os.path.exists(result_store._get_result_file_path(result1))) print ' running for the second time with stored results...' self.fextractor.run(parallelize=True) results = self.fextractor.results # ignore NaN for result in results: result.set_score_aggregate_method(ListStats.nonemean) self.assertAlmostEqual(results[0]['STRRED_feature_srred_score'], 5829.2644469999996, places=4) self.assertAlmostEqual(results[0]['STRRED_feature_trred_score'], 13086.862734, places=4) self.assertAlmostEqual(results[0]['STRRED_feature_strred_score'], 62207779.127545856, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_srred_score'], 0.0, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_trred_score'], 0.0, places=4) self.assertAlmostEqual(results[1]['STRRED_feature_strred_score'], 0.0, places=4)