def test_flat_value10(self):
print 'test on flat pattern of value 10...'
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.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm")[0], 1.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 21.899511, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "motion")[0], 0.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif")[0], 1.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 149.780313, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 149.780392, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 2753999.99219, places=1)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 2754000.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 29.045954, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0],2073600.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 2073600.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 32400.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 32400.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 65.573967, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 65.573967, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 16.667711, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 16.667747, places=3)
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_train_test_on_raw_dataset_with_dis1st_thr(self):
train_dataset = import_python_file(
VmafConfig.test_resource_path('raw_dataset_sample.py'))
model_param = import_python_file(
VmafConfig.test_resource_path('model_param_sample.py'))
feature_param = import_python_file(
VmafConfig.test_resource_path('feature_param_sample.py'))
train_fassembler, train_assets, train_stats, test_fassembler, test_assets, test_stats, _ = train_test_vmaf_on_dataset(
train_dataset=train_dataset,
test_dataset=train_dataset,
feature_param=feature_param,
model_param=model_param,
train_ax=None,
test_ax=None,
result_store=None,
parallelize=True,
logger=None,
fifo_mode=True,
output_model_filepath=self.output_model_filepath
)
self.train_fassembler = train_fassembler
self.assertTrue(os.path.exists(self.output_model_filepath))
self.assertAlmostEqual(train_stats['ys_label_pred'][0], 93.565459224020742, places=3)
self.assertAlmostEqual(test_stats['ys_label_pred'][0], 93.565459224020742, places=3)
def test_checkerboard_opposite(self):
print 'test on checkerboard pattern opposite...'
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.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm")[0], 0.053996333333333334, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], -5.758091333333334, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.554836666666667, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif")[0], 0.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 149.780313, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 6.66666666667, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 2.984752, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 6.66666666667, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 0.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 65.573967, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 16.667711, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3)
def test_checkerboard_shifted_by_1(self):
print 'test on checkerboard pattern shifted by 1...'
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.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm")[0], 0.7853383333333334, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 7.92623066667, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.5548366667, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif")[0], 0.156834666667, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 2178.5352886666665, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 5178894.51562, places=-1)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 16.669074, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 2908829.0, places=-1)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 128957.796875, places=-2)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 201.15329999999997, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 765.1562903333333, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3)
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_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_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_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_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_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_checkerboard_identical(self):
print 'test on checkerboard pattern identical...'
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.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm")[0], 1.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 21.1138813333, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.554836666666667, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif")[0], 1.0, places=4)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 2773.891225, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 33021350.5, places=-3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 29.8567246667, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 25757432.0, places=-3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 259774.958333, places=1)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 277.120382, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 924.193766, places=3)
self.assertAlmostEquals(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3)
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_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_bitrate(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,
ref_path=ref_path, dis_path=dis_path,
asset_dict={'ref_start_frame':0, 'ref_end_frame':47,
'dis_start_frame':0, 'dis_end_frame':47,
'fps':23.976},)
self.assertAlmostEquals(asset.ref_bitrate_kbps_for_entire_file,
53693.964287999996, places=4)
self.assertAlmostEquals(asset.dis_bitrate_kbps_for_entire_file,
53693.964287999996, 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 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_read_dataset_mixed(self):
dataset_path = VmafConfig.test_resource_path('test_dataset_mixed.py')
dataset = import_python_file(dataset_path)
assets = read_dataset(dataset)
self.assertEquals(len(assets), 4)
self.assertEqual(assets[0].resampling_type, 'bilinear')
self.assertEqual(assets[0].ref_yuv_type, 'yuv420p')
self.assertEqual(assets[0].dis_yuv_type, 'yuv420p')
self.assertEqual(assets[0].ref_width_height, (1920, 1080))
self.assertEqual(assets[0].dis_width_height, (1920, 1080))
self.assertEqual(assets[1].resampling_type, 'bilinear')
self.assertEqual(assets[1].ref_yuv_type, 'yuv420p')
self.assertEqual(assets[1].dis_yuv_type, 'notyuv')
self.assertEqual(assets[1].ref_width_height, (1920, 1080))
self.assertEqual(assets[1].dis_width_height, None)
self.assertEqual(assets[2].resampling_type, 'bilinear')
self.assertEqual(assets[2].ref_yuv_type, 'yuv420p')
self.assertEqual(assets[2].dis_yuv_type, 'yuv420p')
self.assertEqual(assets[2].ref_width_height, (720, 480))
self.assertEqual(assets[2].dis_width_height, (720, 480))
self.assertEqual(assets[3].resampling_type, 'bilinear')
self.assertEqual(assets[3].ref_yuv_type, 'yuv420p')
self.assertEqual(assets[3].dis_yuv_type, 'notyuv')
self.assertEqual(assets[3].ref_width_height, (720, 480))
self.assertEqual(assets[3].dis_width_height, None)
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_with(self):
with YuvReader(
filepath=VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv"),
width=576,
height=324,
yuv_type='yuv420p'
) as yuv_reader:
self.assertEquals(yuv_reader.file.__class__, file)
def test_kflk_metrics_performance(self):
mat_filepath = VmafConfig.test_resource_path('data_Toyama.mat')
mat_dict = scipy.io.loadmat(mat_filepath)
results = KflkPerfMetric._metrics_performance(mat_dict['objScoDif'], mat_dict['signif'])
self.assertAlmostEqual(np.mean(results['AUC_DS']), 0.69767003960902052, places=6)
self.assertAlmostEqual(np.mean(results['AUC_BW']), 0.94454700301894534, places=6)
self.assertAlmostEqual(np.mean(results['CC_0']), 0.88105386206276415, places=6)
self.assertAlmostEqual(np.mean(results['THR']), 6.2392849606450556, places=6)
def test_read_dataset_crop_and_pad(self):
train_dataset_path = VmafConfig.test_resource_path('example_dataset_crop_pad.py')
train_dataset = import_python_file(train_dataset_path)
train_assets = read_dataset(train_dataset)
self.assertEquals(len(train_assets), 3)
self.assertEquals(str(train_assets[0]), "example_0_1_src01_hrc00_576x324_576x324_vs_src01_hrc01_576x324_576x324_q_576x324_crop288:162:144:81")
self.assertEquals(str(train_assets[1]), "example_0_2_src01_hrc00_576x324_576x324_vs_src01_hrc01_576x324_576x324_q_576x324_padiw+100:ih+100:50:50")
self.assertEquals(str(train_assets[2]), "example_0_3_src01_hrc00_576x324_576x324_vs_src01_hrc01_576x324_576x324_q_576x324_crop288:162:144:81_padiw+288:ih+162:144:81")
def test_read_image_dataset_notyuv(self):
dataset_path = VmafConfig.test_resource_path('test_image_dataset_notyuv.py')
dataset = import_python_file(dataset_path)
assets = read_dataset(dataset)
self.assertEquals(len(assets), 4)
self.assertTrue(assets[0].ref_width_height is None)
self.assertTrue(assets[0].dis_width_height is None)
self.assertEquals(assets[0].quality_width_height, (1920, 1080))
def test_explain_train_test_model(self):
model_class = SklearnRandomForestTrainTestModel
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)
fextractor = MomentNorefFeatureExtractor(
train_assets,
None,
fifo_mode=True,
delete_workdir=True,
result_store=None,
optional_dict=None,
optional_dict2=None,
)
fextractor.run(parallelize=True)
self.features = fextractor.results
xys = model_class.get_xys_from_results(self.features[:7])
model = model_class({'norm_type':'normalize', 'random_state':0}, None)
model.train(xys)
np.random.seed(0)
xs = model_class.get_xs_from_results(self.features[7:])
explainer = LocalExplainer(neighbor_samples=1000)
exps = explainer.explain(model, xs)
self.assertAlmostEqual(exps['feature_weights'][0, 0], -0.12416, places=4)
self.assertAlmostEqual(exps['feature_weights'][1, 0], 0.00076, places=4)
self.assertAlmostEqual(exps['feature_weights'][0, 1], -0.20931, places=4)
self.assertAlmostEqual(exps['feature_weights'][1, 1], -0.01245, places=4)
self.assertAlmostEqual(exps['feature_weights'][0, 2], 0.02322, places=4)
self.assertAlmostEqual(exps['feature_weights'][1, 2], 0.03673, places=4)
self.assertAlmostEqual(exps['features'][0, 0], 107.73501, places=4)
self.assertAlmostEqual(exps['features'][1, 0], 35.81638, places=4)
self.assertAlmostEqual(exps['features'][0, 1], 13691.23881, places=4)
self.assertAlmostEqual(exps['features'][1, 1], 1611.56764, places=4)
self.assertAlmostEqual(exps['features'][0, 2], 2084.40542, places=4)
self.assertAlmostEqual(exps['features'][1, 2], 328.75389, places=4)
self.assertAlmostEqual(exps['features_normalized'][0, 0], -0.65527, places=4)
self.assertAlmostEqual(exps['features_normalized'][1, 0], -3.74922, places=4)
self.assertAlmostEqual(exps['features_normalized'][0, 1], -0.68872, places=4)
self.assertAlmostEqual(exps['features_normalized'][1, 1], -2.79586, places=4)
self.assertAlmostEqual(exps['features_normalized'][0, 2], 0.08524, places=4)
self.assertAlmostEqual(exps['features_normalized'][1, 2], -1.32625, places=4)
self.assertEqual(exps['feature_names'],
['Moment_noref_feature_1st_score',
'Moment_noref_feature_2nd_score',
'Moment_noref_feature_var_score']
)
def test_yuv_reader(self):
yuv_reader = YuvReader(
filepath=VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv422p10le.yuv"),
width=576,
height=324,
yuv_type='yuv422p10le'
)
self.assertEquals(yuv_reader.num_bytes, 35831808)
self.assertEquals(yuv_reader.num_frms, 48)
self.assertEquals(yuv_reader._get_uv_width_height_multiplier(), (0.5, 1.0))
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 setUp(self):
train_dataset_path = VmafConfig.test_resource_path(
"test_image_dataset_diffdim2.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_next_y_u_v_gray(self):
with YuvReader(filepath=VmafConfig.test_resource_path(
"yuv", "src01_hrc00_576x324.yuv"),
width=576,
height=324,
yuv_type='gray') as yuv_reader:
y, u, v = yuv_reader.next()
y = y.astype(np.double)
self.assertEqual(y[0][0], 87)
self.assertTrue(u is None)
self.assertTrue(v is None)
self.assertAlmostEqual(y.mean(), 61.928749785665296, places=4)
y, u, v = yuv_reader.next()
y = y.astype(np.double)
self.assertEqual(y[0][0], 92)
self.assertTrue(u is None)
self.assertTrue(v is None)
def test_iteration(self):
y_1stmoments = []
y_2ndmoments = []
with YuvReader(filepath=VmafConfig.test_resource_path(
"yuv", "src01_hrc01_576x324.yuv"),
width=576,
height=324,
yuv_type='yuv420p') as yuv_reader:
for y, u, v in yuv_reader:
y_1stmoments.append(y.mean())
y_2ndmoments.append(y.var() + y.mean() * y.mean())
self.assertEqual(len(y_1stmoments), 48)
self.assertEqual(len(y_2ndmoments), 48)
self.assertAlmostEqual(np.mean(y_1stmoments),
61.332006624999984,
places=4)
self.assertAlmostEqual(np.mean(y_2ndmoments),
4798.659574041666,
places=4)
def test_test_on_dataset_mle(self):
from vmaf.routine import run_test_on_dataset
test_dataset = import_python_file(
VmafConfig.test_resource_path('raw_dataset_sample.py'))
test_assets, results = run_test_on_dataset(test_dataset,
VmafQualityRunner,
None,
None,
None,
parallelize=True,
aggregate_method=None,
subj_model_class=MosModel)
self.assertAlmostEqual(results[0]['VMAF_score'],
99.142659046424384,
places=4)
self.assertAlmostEqual(results[1]['VMAF_score'],
35.066157497128764,
places=4)
self.assertAlmostEqual(results[2]['VMAF_score'],
97.428042675471147,
places=4)
self.assertAlmostEqual(results[3]['VMAF_score'],
97.427927701008869,
places=4)
self.assertAlmostEqual(test_assets[0].groundtruth, 100, places=4)
self.assertAlmostEqual(test_assets[1].groundtruth, 50, places=4)
self.assertAlmostEqual(test_assets[2].groundtruth, 90, places=4)
self.assertAlmostEqual(test_assets[3].groundtruth, 80, places=4)
self.assertAlmostEqual(test_assets[0].groundtruth_std, 0.0, places=4)
self.assertAlmostEqual(test_assets[1].groundtruth_std,
3.5355339059327373,
places=4)
self.assertAlmostEqual(test_assets[2].groundtruth_std, 0.0, places=4)
self.assertAlmostEqual(test_assets[3].groundtruth_std,
3.5355339059327373,
places=4)
def test_test_on_dataset_plot_per_content(self):
from vmaf.routine import run_test_on_dataset
test_dataset = import_python_file(
VmafConfig.test_resource_path('dataset_sample.py'))
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1, figsize=[20, 20])
run_test_on_dataset(test_dataset, VmafQualityRunner, ax,
None, VmafConfig.model_path("vmaf_float_v0.6.1.json"),
parallelize=False,
fifo_mode=False,
aggregate_method=None,
point_label='asset_id',
do_plot=['aggregate', # plots all contents in one figure
'per_content' # plots a separate figure per content
],
plot_linear_fit=True # adds linear fit line to each plot
)
output_dir = VmafConfig.workspace_path("output", "test_output")
DisplayConfig.show(write_to_dir=output_dir)
self.assertEqual(len(glob.glob(os.path.join(output_dir, '*.png'))), 3)
if os.path.exists(output_dir):
shutil.rmtree(output_dir)
def test_run_vmafossexec_runner_with_ci_and_custom_model(self):
print 'test on running VMAFOSSEXEC runner with conf interval and custom model...'
ref_path, dis_path, asset, asset_original = set_default_576_324_videos_for_testing()
self.runner = VmafossExecQualityRunner(
[asset, asset_original],
None, fifo_mode=True,
delete_workdir=True,
result_store=None,
optional_dict={
'model_filepath': VmafConfig.test_resource_path('model', 'vmafplus_v0.5.2boot_test.pkl'),
'ci': True
},
)
self.runner.run()
results = self.runner.results
self.assertAlmostEqual(results[0]['VMAFOSSEXEC_score'], 75.443043750000001, places=3)
self.assertAlmostEqual(results[1]['VMAFOSSEXEC_score'], 99.958047916666672, places=4)
self.assertAlmostEqual(results[0]['VMAFOSSEXEC_bagging_score'], 75.13012623785923, places=3)
self.assertAlmostEqual(results[1]['VMAFOSSEXEC_bagging_score'], 99.96504855577571, places=4)
self.assertAlmostEqual(results[0]['VMAFOSSEXEC_stddev_score'], 0.6812993325967104, places=3)
self.assertAlmostEqual(results[1]['VMAFOSSEXEC_stddev_score'], 0.03947607207290399, places=4)
def test_read_dataset_crop_and_pad(self):
train_dataset_path = VmafConfig.test_resource_path(
'example_dataset_crop_pad.py')
train_dataset = import_python_file(train_dataset_path)
train_assets = read_dataset(train_dataset)
train_assets[0].asset_dict['ref_crop_cmd'] = '288:162:144:81'
train_assets[1].asset_dict['ref_pad_cmd'] = 'iw+100:ih+100:50:50'
train_assets[2].asset_dict['ref_crop_cmd'] = '288:162:144:81'
train_assets[2].asset_dict['ref_pad_cmd'] = 'iw+288:ih+162:144:81'
self.assertEqual(len(train_assets), 3)
self.assertEqual(
str(train_assets[0]),
"example_0_1_src01_hrc00_576x324_576x324_crop288:162:144:81_vs_src01_hrc01_576x324_576x324_crop288:162:144:81_q_576x324"
)
self.assertEqual(
str(train_assets[1]),
"example_0_2_src01_hrc00_576x324_576x324_padiw+100:ih+100:50:50_vs_src01_hrc01_576x324_576x324_padiw+100:ih+100:50:50_q_576x324"
)
self.assertEqual(
str(train_assets[2]),
"example_0_3_src01_hrc00_576x324_576x324_crop288:162:144:81_padiw+288:ih+162:144:81_vs_src01_hrc01_576x324_576x324_crop288:162:144:81_padiw+288:ih+162:144:81_q_576x324"
)
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.9808006041666667,
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 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_feature),
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)
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_feature),
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)
dataset_name = 'example_image'
yuv_fmt = 'notyuv'
quality_width = 1920
quality_height = 1080
from vmaf.config import VmafConfig
ref_videos = [
{'content_id': 0, 'path': VmafConfig.test_resource_path('icpf', 'frame00000001.icpf')},
{'content_id': 1, 'path': VmafConfig.test_resource_path('icpf', 'frame00000002.icpf')},
]
dis_videos = [
{'content_id': 0, 'asset_id': 0, 'dmos': 100, 'path': VmafConfig.test_resource_path('icpf', 'frame00000000.icpf')}, # ref
{'content_id': 0, 'asset_id': 1, 'dmos': 50, 'path': VmafConfig.test_resource_path('icpf', 'frame00000001.icpf')},
{'content_id': 1, 'asset_id': 2, 'dmos': 100, 'path': VmafConfig.test_resource_path('icpf', 'frame00000002.icpf')}, # ref
{'content_id': 1, 'asset_id': 3, 'dmos': 80, 'path': VmafConfig.test_resource_path('icpf', 'frame00000003.icpf')},
]
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_explain_train_test_model(self):
model_class = SklearnRandomForestTrainTestModel
train_dataset_path = VmafConfig.test_resource_path(
'test_image_dataset_diffdim2.py')
train_dataset = import_python_file(train_dataset_path)
train_assets = read_dataset(train_dataset)
fextractor = MomentNorefFeatureExtractor(
train_assets,
None,
fifo_mode=True,
delete_workdir=True,
result_store=None,
optional_dict=None,
optional_dict2=None,
)
fextractor.run(parallelize=True)
self.features = fextractor.results
xys = model_class.get_xys_from_results(self.features[:7])
model = model_class(
{
'norm_type': 'normalize',
'n_estimators': 10,
'random_state': 0
}, None)
model.train(xys)
np.random.seed(0)
xs = model_class.get_xs_from_results(self.features[7:])
explainer = LocalExplainer(neighbor_samples=1000)
exps = explainer.explain(model, xs)
self.assertAlmostEqual(exps['feature_weights'][0, 0],
-0.12416,
places=4)
self.assertAlmostEqual(exps['feature_weights'][1, 0],
0.00076,
places=4)
self.assertAlmostEqual(exps['feature_weights'][0, 1],
-0.20931,
places=4)
self.assertAlmostEqual(exps['feature_weights'][1, 1],
-0.01245,
places=4)
self.assertAlmostEqual(exps['feature_weights'][0, 2],
0.02322,
places=4)
self.assertAlmostEqual(exps['feature_weights'][1, 2],
0.03673,
places=4)
self.assertAlmostEqual(exps['features'][0, 0], 107.73501, places=4)
self.assertAlmostEqual(exps['features'][1, 0], 35.81638, places=4)
self.assertAlmostEqual(exps['features'][0, 1], 13691.23881, places=4)
self.assertAlmostEqual(exps['features'][1, 1], 1611.56764, places=4)
self.assertAlmostEqual(exps['features'][0, 2], 2084.40542, places=4)
self.assertAlmostEqual(exps['features'][1, 2], 328.75389, places=4)
self.assertAlmostEqual(exps['features_normalized'][0, 0],
-0.65527,
places=4)
self.assertAlmostEqual(exps['features_normalized'][1, 0],
-3.74922,
places=4)
self.assertAlmostEqual(exps['features_normalized'][0, 1],
-0.68872,
places=4)
self.assertAlmostEqual(exps['features_normalized'][1, 1],
-2.79586,
places=4)
self.assertAlmostEqual(exps['features_normalized'][0, 2],
0.08524,
places=4)
self.assertAlmostEqual(exps['features_normalized'][1, 2],
-1.32625,
places=4)
self.assertEqual(exps['feature_names'], [
'Moment_noref_feature_1st_score', 'Moment_noref_feature_2nd_score',
'Moment_noref_feature_var_score'
])
def setUp(self) -> None:
for i in range(4):
VmafConfig.test_resource_path('tiff', 'src01_hrc00_576x324%05d.tiff' % (i+1))
VmafConfig.test_resource_path('tiff', 'src01_hrc01_576x324%05d.tiff' % (i+1))
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.json')
self.param_filename = VmafConfig.test_resource_path('vmaf_v4.py')
self.batch_filename = VmafConfig.workdir_path('test_batch_input')
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_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_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_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_read_dataset_fps_bad_rebuf_indices(self):
train_dataset_path = VmafConfig.test_resource_path('test_dataset_fps_bad_rebufinds.py')
train_dataset = import_python_file(train_dataset_path)
with self.assertRaises(AssertionError):
train_assets = read_dataset(train_dataset)
from vmaf.config import VmafConfig
dataset_name = 'test_image'
yuv_fmt = 'yuv444p'
dataset_dir = VmafConfig.test_resource_path('test_image_yuv')
ref_videos = [
{
'content_id': 0,
'content_name': '100007',
'height': 321,
'path': dataset_dir + '/100007.yuv',
'width': 481
},
{
'content_id': 1,
'content_name': '100039',
'height': 321,
'path': dataset_dir + '/100039.yuv',
'width': 481
},
{
'content_id': 2,
'content_name': '100075',
'height': 321,
'path': dataset_dir + '/100075.yuv',
'width': 481
},
{
'content_id': 4,
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_load_result_with_none(self):
result = FileSystemResultStore.load_result(VmafConfig.test_resource_path('result_with_none.txt'))
result.set_score_aggregate_method(ListStats.nonemean)
self.assertAlmostEqual(result['STRRED_feature_srred_score'], 5829.2644469999996, places=4)
class FeatureTest(unittest.TestCase):
LOG_FILENAME = VmafConfig.workdir_path("logFeatureTest")
REF_YUV = VmafConfig.test_resource_path("yuv", "src01_hrc00_576x324.yuv")
DIS_YUV = VmafConfig.test_resource_path("yuv", "src01_hrc01_576x324.yuv")
YUV_FMT = "yuv420p"
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_feature),
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_num_scale0")
self.assertAlmostEqual(score, 45.5277493125, 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_feature),
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.164776875, 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_feature),
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_feature),
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_feature),
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.4460930625000001, 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_feature),
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.509571520833337, 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.164776874999994, 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_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_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_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_feature),
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_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_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_feature),
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_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)
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'
print 'test adm on yuv422p10le...'
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.assertAlmostEquals(score, 0.9345877708333336, places=4)
score, scores = read_log(ADM_LOG, "adm_num")
self.assertAlmostEquals(score, 371.8354140624999, places=4)
score, scores = read_log(ADM_LOG, "adm_den")
self.assertAlmostEquals(score, 397.8337897291667, places=4)
score, scores = read_log(ADM_LOG, "adm_den_scale0")
self.assertAlmostEquals(score, 50.143851375000004, places=4)
score, scores = read_log(ADM_LOG, "adm_num_scale1")
self.assertAlmostEquals(score, 66.58064533333334, places=4)
score, scores = read_log(ADM_LOG, "adm_den_scale1")
self.assertAlmostEquals(score, 74.47438285416666, places=4)
score, scores = read_log(ADM_LOG, "adm_num_scale2")
self.assertAlmostEquals(score, 105.56477879166668, places=4)
score, scores = read_log(ADM_LOG, "adm_den_scale2")
self.assertAlmostEquals(score, 113.49725852083333, places=4)
score, scores = read_log(ADM_LOG, "adm_num_scale3")
self.assertAlmostEquals(score, 154.16224066666666, places=4)
score, scores = read_log(ADM_LOG, "adm_den_scale3")
self.assertAlmostEquals(score, 159.71829710416668, places=4)
def test_ansnr(self):
ANSNR_LOG = self. LOG_FILENAME + '_ansnr'
print 'test ansnr on yuv422p10le...'
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.assertAlmostEquals(score, 23.5095715208, places=4)
score, scores = read_log(ANSNR_LOG, "anpsnr")
self.assertAlmostEquals(score, 34.1902860625, places=4)
def test_motion(self):
MOTION_LOG = self.LOG_FILENAME + '_motion'
print 'test motion on yuv422p10le...'
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.assertAlmostEquals(score, 4.04982535417, places=4)
def test_vif(self):
VIF_LOG = self.LOG_FILENAME + '_vif'
print 'test vif on yuv422p10le...'
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.assertAlmostEquals(score, 0.4460930625, places=4)
self.assertAlmostEquals(scores[0], 0.580304, places=4)
self.assertAlmostEquals(scores[1], 0.492477, places=4)
score, scores = read_log(VIF_LOG, "vif_num")
self.assertAlmostEquals(score, 712650.023478, places=0)
score, scores = read_log(VIF_LOG, "vif_den")
self.assertAlmostEquals(score, 1597314.95249, places=0)
score, scores = read_log(VIF_LOG, "vif_num_scale0")
self.assertAlmostEquals(score, 468101.509766, places=0)
score, scores = read_log(VIF_LOG, "vif_num_scale1")
self.assertAlmostEquals(score, 184971.572266, places=1)
score, scores = read_log(VIF_LOG, "vif_num_scale2")
self.assertAlmostEquals(score, 47588.8323567, places=0)
score, scores = read_log(VIF_LOG, "vif_num_scale3")
self.assertAlmostEquals(score, 11988.1090902, places=1)
score, scores = read_log(VIF_LOG, "vif_den_scale0")
self.assertAlmostEquals(score, 1287822.80208, places=0)
score, scores = read_log(VIF_LOG, "vif_den_scale1")
self.assertAlmostEquals(score, 241255.067708, places=1)
score, scores = read_log(VIF_LOG, "vif_den_scale2")
self.assertAlmostEquals(score, 55149.8169759, places=2)
score, scores = read_log(VIF_LOG, "vif_den_scale3")
self.assertAlmostEquals(score, 13087.2657267, places=2)
def test_all(self):
ALL_LOG = self.LOG_FILENAME + "_all"
print 'test all on yuv422p10le...'
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.assertAlmostEquals(score, 0.4460930625, places=4)
score, scores = read_log(ALL_LOG, "motion")
self.assertAlmostEquals(score, 4.04982535417, places=4)
score, scores = read_log(ALL_LOG, "ansnr")
self.assertAlmostEquals(score, 23.5095715208, places=4)
score, scores = read_log(ALL_LOG, "adm")
self.assertAlmostEquals(score, 0.9345877708333336, places=4)
score, scores = read_log(ALL_LOG, "adm_num")
self.assertAlmostEquals(score, 371.8354140624999, places=4)
score, scores = read_log(ALL_LOG, "adm_den")
self.assertAlmostEquals(score, 397.8337897291667, places=4)
score, scores = read_log(ALL_LOG, "vif_num")
self.assertAlmostEquals(score, 712650.023478, places=0)
score, scores = read_log(ALL_LOG, "vif_den")
self.assertAlmostEquals(score, 1597314.95249, places=0)
score, scores = read_log(ALL_LOG, "anpsnr")
self.assertAlmostEquals(score, 34.1902860625, places=4)
score, scores = read_log(ALL_LOG, "vif_num_scale0")
self.assertAlmostEquals(score, 468101.509766, places=0)
score, scores = read_log(ALL_LOG, "vif_num_scale1")
self.assertAlmostEquals(score, 184971.572266, places=1)
score, scores = read_log(ALL_LOG, "vif_num_scale2")
self.assertAlmostEquals(score, 47588.8323567, places=0)
score, scores = read_log(ALL_LOG, "vif_num_scale3")
self.assertAlmostEquals(score, 11988.1090902, places=1)
score, scores = read_log(ALL_LOG, "vif_den_scale0")
self.assertAlmostEquals(score, 1287822.80208, places=0)
score, scores = read_log(ALL_LOG, "vif_den_scale1")
self.assertAlmostEquals(score, 241255.067708, places=1)
score, scores = read_log(ALL_LOG, "vif_den_scale2")
self.assertAlmostEquals(score, 55149.8169759, places=2)
score, scores = read_log(ALL_LOG, "vif_den_scale3")
self.assertAlmostEquals(score, 13087.2657267, places=2)
score, scores = read_log(ALL_LOG, "adm_den_scale0")
self.assertAlmostEquals(score, 50.143851375000004, places=4)
score, scores = read_log(ALL_LOG, "adm_num_scale1")
self.assertAlmostEquals(score, 66.58064533333334, places=4)
score, scores = read_log(ALL_LOG, "adm_den_scale1")
self.assertAlmostEquals(score, 74.47438285416666, places=4)
score, scores = read_log(ALL_LOG, "adm_num_scale2")
self.assertAlmostEquals(score, 105.56477879166668, places=4)
score, scores = read_log(ALL_LOG, "adm_den_scale2")
self.assertAlmostEquals(score, 113.49725852083333, places=4)
score, scores = read_log(ALL_LOG, "adm_num_scale3")
self.assertAlmostEquals(score, 154.16224066666666, places=4)
score, scores = read_log(ALL_LOG, "adm_den_scale3")
self.assertAlmostEquals(score, 159.71829710416668, places=4)
def test_psnr(self):
PSNR_LOG = self.LOG_FILENAME + '_psnr'
print 'test psnr on yuv422p10le...'
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.assertAlmostEquals(score, 30.7805732917, places=4)
self.assertAlmostEquals(scores[0], 34.786288, places=4)
self.assertAlmostEquals(scores[1], 31.908737, places=4)
def test_ssim(self):
SSIM_LOG = self.LOG_FILENAME + '_ssim'
print 'test ssim on yuv422p10le...'
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.assertAlmostEquals(score, 0.863226541666667, places=4)
self.assertAlmostEquals(scores[0], 0.925023, places=4)
self.assertAlmostEquals(scores[1], 0.891992, places=4)
score, scores = read_log(SSIM_LOG, "ssim_l")
self.assertAlmostEquals(score,0.998147458333333, places=4)
self.assertAlmostEquals(scores[0], 0.999524, places=4)
self.assertAlmostEquals(scores[1], 0.998983, places=4)
score, scores = read_log(SSIM_LOG, "ssim_c")
self.assertAlmostEquals(score, 0.9612679375000001, places=4)
self.assertAlmostEquals(scores[0], 0.979614, places=4)
self.assertAlmostEquals(scores[1], 0.96981, places=4)
score, scores = read_log(SSIM_LOG, "ssim_s")
self.assertAlmostEquals(score, 0.8977363333333335, places=4)
self.assertAlmostEquals(scores[0], 0.943966, places=4)
self.assertAlmostEquals(scores[1], 0.919507, places=4)
def test_ms_ssim(self):
MS_SSIM_LOG = self.LOG_FILENAME + '_msssim'
print 'test ms_ssim on yuv422p10le...'
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.assertAlmostEquals(score, 0.9632498125, places=4)
self.assertAlmostEquals(scores[0], 0.981968, places=4)
self.assertAlmostEquals(scores[1], 0.973366, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale0")
self.assertAlmostEquals(score, 0.998147458333333, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale0")
self.assertAlmostEquals(score, 0.9612679375000001, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale0")
self.assertAlmostEquals(score, 0.8977363333333335, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale1")
self.assertAlmostEquals(score, 0.9989961250000002, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale1")
self.assertAlmostEquals(score, 0.9857694375, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale1")
self.assertAlmostEquals(score, 0.941185875, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale2")
self.assertAlmostEquals(score, 0.9992356458333332, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale2")
self.assertAlmostEquals(score, 0.997034020833, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale2")
self.assertAlmostEquals(score, 0.977992145833, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale3")
self.assertAlmostEquals(score, 0.9992921041666665, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale3")
self.assertAlmostEquals(score, 0.9995884375000003, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale3")
self.assertAlmostEquals(score, 0.9938712499999998, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_l_scale4")
self.assertAlmostEquals(score, 0.9994035625000003, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_c_scale4")
self.assertAlmostEquals(score, 0.999907625, places=4)
score, scores = read_log(MS_SSIM_LOG, "ms_ssim_s_scale4")
self.assertAlmostEquals(score,0.998222583333, places=4)
