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