Ejemplo n.º 1
0
    def test_adm(self):
        ADM_LOG = self.LOG_FILENAME + '_adm'
        print 'test adm...'
        cmd = "{vmaf} adm {fmt} {ref} {dis} {w} {h} > {log}".format(
            vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV,
            w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=ADM_LOG
        )
        run_process(cmd, shell=True)
        score, scores = read_log(ADM_LOG, "adm")
        self.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_num_scale0")
        self.assertAlmostEquals(score, 45.5277493125, 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)
Ejemplo n.º 2
0
    def _generate_result(self, asset):
        # routine to call the command-line executable and generate feature
        # scores in the log file.

        log_file_path = self._get_log_file_path(asset)

        # run VMAF command line to extract features, APPEND (>>) result (since
        # _prepare_generate_log_file method has already created the file and
        # written something in advance).
        quality_width, quality_height = asset.quality_width_height
        vmaf_feature_cmd = "{vmaf} all {yuv_type} {ref_path} {dis_path} {w} {h} >> {log_file_path}" \
        .format(
            vmaf=ExternalProgram.vmaf,
            yuv_type=self._get_workfile_yuv_type(asset),
            ref_path=asset.ref_workfile_path,
            dis_path=asset.dis_workfile_path,
            w=quality_width,
            h=quality_height,
            log_file_path=log_file_path,
        )

        if self.logger:
            self.logger.info(vmaf_feature_cmd)

        run_process(vmaf_feature_cmd, shell=True)
Ejemplo n.º 3
0
    def _generate_result(self, asset):
        # routine to call the command-line executable and generate quality
        # scores in the log file.

        ref_procfile_path = asset.ref_procfile_path
        dis_procfile_path = asset.dis_procfile_path
        log_file_path = self._get_log_file_path(asset)

        current_dir = os.getcwd() + '/'

        ref_procfile_path = make_absolute_path(ref_procfile_path, current_dir)
        dis_procfile_path = make_absolute_path(dis_procfile_path, current_dir)
        log_file_path = make_absolute_path(log_file_path, current_dir)

        quality_width, quality_height = asset.quality_width_height

        strred_cmd = '''{matlab} -nodisplay -nosplash -nodesktop -r "run_strred('{ref}', '{dis}', {h}, {w}); exit;" >> {log_file_path}'''.format(
            matlab=VmafExternalConfig.get_and_assert_matlab(),
            ref=ref_procfile_path,
            dis=dis_procfile_path,
            w=quality_width,
            h=quality_height,
            log_file_path=log_file_path,
        )
        if self.logger:
            self.logger.info(strred_cmd)

        os.chdir(self.MATLAB_WORKSPACE)
        run_process(strred_cmd, shell=True)
        os.chdir(current_dir)
Ejemplo n.º 4
0
    def _generate_result(self, asset):
        # routine to call the command-line executable and generate quality
        # scores in the log file.

        ref_workfile_path = asset.ref_workfile_path
        dis_workfile_path = asset.dis_workfile_path
        log_file_path = self._get_log_file_path(asset)

        current_dir = os.getcwd() + '/'

        ref_workfile_path = make_absolute_path(ref_workfile_path, current_dir)
        dis_workfile_path = make_absolute_path(dis_workfile_path, current_dir)
        log_file_path = make_absolute_path(log_file_path, current_dir)

        quality_width, quality_height = asset.quality_width_height

        strred_cmd = '''{matlab} -nodisplay -nosplash -nodesktop -r "run_strred('{ref}', '{dis}', {h}, {w}); exit;" >> {log_file_path}'''.format(
            matlab=VmafExternalConfig.get_and_assert_matlab(),
            ref=ref_workfile_path,
            dis=dis_workfile_path,
            w=quality_width,
            h=quality_height,
            log_file_path=log_file_path,
        )
        if self.logger:
            self.logger.info(strred_cmd)

        os.chdir(self.MATLAB_WORKSPACE)
        run_process(strred_cmd, shell=True)
        os.chdir(current_dir)
Ejemplo n.º 5
0
    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)
Ejemplo n.º 6
0
    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)
Ejemplo n.º 7
0
    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)
Ejemplo n.º 8
0
    def test_checkerboard_opposite(self):

        LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_checkerboard_opposite'
        ref_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv")
        dis_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_10_0.yuv")
        yuv_fmt = "yuv420p"
        yuv_width = 1920
        yuv_height = 1080
        cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv,
                                       dis=dis_yuv, w=yuv_width, h=yuv_height,
                                       log=LOCAL_LOG_FILENAME)
        run_process(cmd, shell=True)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 0.053996333333333334, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], -5.758091333333334, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.554836666666667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 12.554836666666667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 0.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 149.780313, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 6.66666666667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 2.984752, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 6.66666666667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 0.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3)

        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 65.573967, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 16.667711, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3)
Ejemplo n.º 9
0
    def test_flat_value10(self):

        LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_flat_value10'
        ref_yuv = VmafConfig.test_resource_path("yuv", "flat_1920_1080_0.yuv")
        dis_yuv = VmafConfig.test_resource_path("yuv", "flat_1920_1080_10.yuv")
        yuv_fmt = "yuv420p"
        yuv_width = 1920
        yuv_height = 1080
        cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv,
                                       dis=dis_yuv, w=yuv_width, h=yuv_height,
                                       log=LOCAL_LOG_FILENAME)
        run_process(cmd, shell=True)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 1.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 21.899511, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 0.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 0.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 1.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 149.780313, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 149.780392, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 2753999.99219, places=1)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 2754000.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 29.045954, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0],2073600.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 2073600.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 32400.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 32400.0, places=4)

        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 65.573967, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 65.573967, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 16.667711, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 16.667747, places=3)
Ejemplo n.º 10
0
    def test_checkerboard_identical(self):

        LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_checkerboardIdentical'
        ref_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv")
        dis_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv")
        yuv_fmt = "yuv420p"
        yuv_width = 1920
        yuv_height = 1080
        cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv,
                                       dis=dis_yuv, w=yuv_width, h=yuv_height,
                                       log=LOCAL_LOG_FILENAME)
        run_process(cmd, shell=True)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 1.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 21.1138813333, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.554836666666667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 12.554836666666667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 1.0, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 2773.891225, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 33021350.5, places=-3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 29.8567246667, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 25757432.0, places=-3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 259774.958333, places=1)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3)

        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 277.120382, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 924.193766, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3)
Ejemplo n.º 11
0
    def test_checkerboard_shifted_by_1(self):

        LOCAL_LOG_FILENAME = self.LOG_FILENAME + '_checkerboard_shifted_by_1'
        ref_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_0_0.yuv")
        dis_yuv = VmafConfig.test_resource_path("yuv", "checkerboard_1920_1080_10_3_1_0.yuv")
        yuv_fmt = "yuv420p"
        yuv_width = 1920
        yuv_height = 1080
        cmd = self.CMD_TEMPLATE.format(vmaf=required(ExternalProgram.vmaf), fmt=yuv_fmt, ref=ref_yuv,
                                       dis=dis_yuv, w=yuv_width, h=yuv_height,
                                       log=LOCAL_LOG_FILENAME)
        run_process(cmd, shell=True)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm")[0], 0.7853383333333334, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "ansnr")[0], 7.92623066667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion")[0], 12.5548366667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "motion2")[0], 12.5548366667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif")[0], 0.156834666667, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num")[0], 2178.5352886666665, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den")[0], 2773.891225, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num")[0], 5178894.51562, places=-1)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den")[0], 33021387.0625, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "anpsnr")[0], 16.669074, places=4)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale0")[0], 2908829.0, places=-1)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale0")[0], 25757473.3333, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_num_scale3")[0], 128957.796875, places=-2)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "vif_den_scale3")[0], 259774.9375, places=3)

        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale0")[0], 201.15329999999997, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale0")[0], 277.120382, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_num_scale3")[0], 765.1562903333333, places=3)
        self.assertAlmostEqual(read_log(LOCAL_LOG_FILENAME, "adm_den_scale3")[0], 924.193766, places=3)
Ejemplo n.º 12
0
    def test_adm(self):
        ADM_LOG = self.LOG_FILENAME + '_adm'

        cmd = "{vmaf} adm {fmt} {ref} {dis} {w} {h} > {log}".format(
            vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV,
            w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=ADM_LOG
        )
        run_process(cmd, shell=True)
        score, scores = read_log(ADM_LOG, "adm")
        self.assertAlmostEqual(score, 0.9345877708333336, places=4)
        score, scores = read_log(ADM_LOG, "adm_num")
        self.assertAlmostEqual(score, 371.8354140624999, places=4)
        score, scores = read_log(ADM_LOG, "adm_den")
        self.assertAlmostEqual(score, 397.8337897291667, places=4)
        score, scores = read_log(ADM_LOG, "adm_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)
Ejemplo n.º 13
0
    def test_vif(self):
        VIF_LOG = self.LOG_FILENAME + '_vif'

        cmd = "{vmaf} vif {fmt} {ref} {dis} {w} {h} > {log}".format(
            vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV,
            w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=VIF_LOG
        )
        run_process(cmd, shell=True)
        score, scores = read_log(VIF_LOG, "vif")
        self.assertAlmostEqual(score, 0.4460930625, places=4)
        self.assertAlmostEqual(scores[0], 0.580304, places=4)
        self.assertAlmostEqual(scores[1], 0.492477, places=4)
        score, scores = read_log(VIF_LOG, "vif_num")
        self.assertAlmostEqual(score, 712650.023478, places=0)
        score, scores = read_log(VIF_LOG, "vif_den")
        self.assertAlmostEqual(score, 1597314.95249, places=0)
        score, scores = read_log(VIF_LOG, "vif_num_scale0")
        self.assertAlmostEqual(score, 468101.509766, places=0)
        score, scores = read_log(VIF_LOG, "vif_num_scale1")
        self.assertAlmostEqual(score, 184971.572266, places=1)
        score, scores = read_log(VIF_LOG, "vif_num_scale2")
        self.assertAlmostEqual(score, 47588.8323567, places=0)
        score, scores = read_log(VIF_LOG, "vif_num_scale3")
        self.assertAlmostEqual(score, 11988.1090902, places=1)
        score, scores = read_log(VIF_LOG, "vif_den_scale0")
        self.assertAlmostEqual(score, 1287822.80208, places=0)
        score, scores = read_log(VIF_LOG, "vif_den_scale1")
        self.assertAlmostEqual(score, 241255.067708, places=1)
        score, scores = read_log(VIF_LOG, "vif_den_scale2")
        self.assertAlmostEqual(score, 55149.8169759, places=2)
        score, scores = read_log(VIF_LOG, "vif_den_scale3")
        self.assertAlmostEqual(score, 13087.2657267, places=2)
Ejemplo n.º 14
0
 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)
Ejemplo n.º 15
0
 def test_ssim(self):
     SSIM_LOG = self.LOG_FILENAME + '_ssim'
     print 'test ssim...'
     cmd = "{ssim} {fmt} {ref} {dis} {w} {h} > {log}".format(
         ssim=required(ExternalProgram.ssim),
         fmt=self.YUV_FMT,
         ref=self.REF_YUV,
         dis=self.DIS_YUV,
         w=self.YUV_WIDTH,
         h=self.YUV_HEIGHT,
         log=SSIM_LOG)
     run_process(cmd, shell=True)
     score, scores = read_log(SSIM_LOG, "ssim")
     self.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)
Ejemplo n.º 16
0
    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)
Ejemplo n.º 17
0
    def call_vmafossexec(fmt, w, h, ref_path, dis_path, model, log_file_path, disable_clip_score,
                         enable_transform_score, phone_model, disable_avx, exe=None, logger=None):

        if exe is None:
            exe = required(ExternalProgram.vmafossexec)

        vmafossexec_cmd = "{exe} {fmt} {w} {h} {ref_path} {dis_path} {model} --log {log_file_path} --log-fmt xml --psnr --ssim --ms-ssim" \
            .format(
            exe=exe,
            fmt=fmt,
            w=w,
            h=h,
            ref_path=ref_path,
            dis_path=dis_path,
            model=model,
            log_file_path=log_file_path,
        )
        if disable_clip_score:
            vmafossexec_cmd += ' --disable-clip'
        if enable_transform_score or phone_model:
            vmafossexec_cmd += ' --enable-transform'
        if disable_avx:
            vmafossexec_cmd += ' --disable-avx'
        if logger:
            logger.info(vmafossexec_cmd)
        run_process(vmafossexec_cmd, shell=True)
Ejemplo n.º 18
0
 def test_all(self):
     ALL_LOG = self.LOG_FILENAME + "_all"
     print 'test all...'
     cmd = "{vmaf} all {fmt} {ref} {dis} {w} {h} > {log}".format(
         vmaf=required(ExternalProgram.vmaf),
         fmt=self.YUV_FMT,
         ref=self.REF_YUV,
         dis=self.DIS_YUV,
         w=self.YUV_WIDTH,
         h=self.YUV_HEIGHT,
         log=ALL_LOG)
     run_process(cmd, shell=True)
     score, scores = read_log(ALL_LOG, "vif")
     self.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.509571520833337, 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.164776874999994, 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)
Ejemplo n.º 19
0
    def _open_ref_workfile(self, asset, fifo_mode):
        # For now, only works for YUV format -- all need is to copy from ref
        # file to ref workfile

        # only need to open ref workfile if the path is different from ref path
        assert asset.use_path_as_workpath is False and asset.ref_path != asset.ref_workfile_path

        # if fifo mode, mkfifo
        if fifo_mode:
            os.mkfifo(asset.ref_workfile_path)

        quality_width, quality_height = self._get_quality_width_height(asset)
        yuv_type = asset.ref_yuv_type
        resampling_type = self._get_resampling_type(asset)

        if yuv_type != 'notyuv':
            # in this case, for sure has ref_width_height
            width, height = asset.ref_width_height
            src_fmt_cmd = self._get_yuv_src_fmt_cmd(asset, height, width,
                                                    'ref')
        else:
            src_fmt_cmd = self._get_notyuv_src_fmt_cmd(asset, 'ref')

        workfile_yuv_type = self._get_workfile_yuv_type(asset)

        vframes_cmd, select_cmd = self._get_vframes_cmd(asset, 'ref')
        crop_cmd = self._get_filter_cmd(asset, 'crop', 'ref')
        pad_cmd = self._get_filter_cmd(asset, 'pad', 'ref')
        scale_cmd = 'scale={width}x{height}'.format(width=quality_width,
                                                    height=quality_height)

        filter_cmds = []
        for key in Asset.ORDERED_FILTER_LIST:
            if key is not 'crop' and key is not 'pad':
                filter_cmds.append(self._get_filter_cmd(asset, key, 'ref'))

        vf_cmd = ','.join(
            filter(lambda s: s != '',
                   [select_cmd, crop_cmd, pad_cmd, scale_cmd] + filter_cmds))

        ffmpeg_cmd = '{ffmpeg} {src_fmt_cmd} -i {src} -an -vsync 0 ' \
                     '-pix_fmt {yuv_type} {vframes_cmd} -vf {vf_cmd} -f rawvideo ' \
                     '-sws_flags {resampling_type} -y {dst}'
        ffmpeg_cmd = ffmpeg_cmd.format(
            ffmpeg=VmafExternalConfig.get_and_assert_ffmpeg(),
            src=asset.ref_path,
            dst=asset.ref_workfile_path,
            src_fmt_cmd=src_fmt_cmd,
            vf_cmd=vf_cmd,
            yuv_type=workfile_yuv_type,
            resampling_type=resampling_type,
            vframes_cmd=vframes_cmd,
        )

        if self.logger:
            self.logger.info(ffmpeg_cmd)

        run_process(ffmpeg_cmd, shell=True)
Ejemplo n.º 20
0
 def test_run_vmaf_training_processes2_without_parallelize(self):
     exe = VmafConfig.root_path('python', 'vmaf', 'script', 'run_vmaf_training.py')
     cmd = "{exe} {dataset} {param} {param} {output} --suppress-plot --processes 2".format(
         exe=exe,
         dataset=self.dataset_filename,
         param=self.param_filename,
         output=self.out_model_filepath)
     with self.assertRaises(AssertionError):
         run_process(cmd, shell=True)
Ejemplo n.º 21
0
 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)
Ejemplo n.º 22
0
 def test_motion(self):
     MOTION_LOG = self.LOG_FILENAME + '_motion'
     print 'test motion...'
     cmd = "{vmaf} motion {fmt} {ref} {dis} {w} {h} > {log}".format(
         vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV,
         w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=MOTION_LOG
     )
     run_process(cmd, shell=True)
     score, scores = read_log(MOTION_LOG, "motion")
     self.assertAlmostEquals(score, 4.04982535417, places=4)
Ejemplo n.º 23
0
    def _open_dis_workfile(self, asset, fifo_mode):
        # For now, only works for YUV format -- all need is to copy from dis
        # file to dis workfile

        # only need to open dis workfile if the path is different from dis path
        assert asset.use_path_as_workpath is False and asset.dis_path != asset.dis_workfile_path

        # if fifo mode, mkfifo
        if fifo_mode:
            os.mkfifo(asset.dis_workfile_path)

        quality_width, quality_height = self._get_quality_width_height(asset)
        yuv_type = asset.dis_yuv_type
        resampling_type = self._get_resampling_type(asset)

        if yuv_type != 'notyuv':
            # in this case, for sure has dis_width_height
            width, height = asset.dis_width_height
            src_fmt_cmd = self._get_yuv_src_fmt_cmd(asset, height, width,
                                                    'dis')
        else:
            src_fmt_cmd = self._get_notyuv_src_fmt_cmd(asset, 'dis')

        workfile_yuv_type = self._get_workfile_yuv_type(asset)

        crop_cmd = self._get_dis_crop_cmd(asset)
        pad_cmd = self._get_dis_pad_cmd(asset)
        gblur_cmd = self._get_dis_gblur_cmd(asset)

        vframes_cmd, select_cmd = self._get_vframes_cmd(asset, 'dis')

        scale_cmd = 'scale={width}x{height}'.format(width=quality_width,
                                                    height=quality_height)

        vf_cmd = ','.join(
            filter(lambda s: s != '',
                   [select_cmd, crop_cmd, pad_cmd, scale_cmd, gblur_cmd]))

        ffmpeg_cmd = '{ffmpeg} {src_fmt_cmd} -i {src} -an -vsync 0 ' \
                     '-pix_fmt {yuv_type} {vframes_cmd} -vf {vf_cmd} -f rawvideo ' \
                     '-sws_flags {resampling_type} -y {dst}'.format(
            ffmpeg=VmafExternalConfig.get_and_assert_ffmpeg(),
            src=asset.dis_path, dst=asset.dis_workfile_path,
            src_fmt_cmd=src_fmt_cmd,
            vf_cmd=vf_cmd,
            yuv_type=workfile_yuv_type,
            resampling_type=resampling_type,
            vframes_cmd=vframes_cmd,
        )

        if self.logger:
            self.logger.info(ffmpeg_cmd)

        run_process(ffmpeg_cmd, shell=True)
Ejemplo n.º 24
0
 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)
Ejemplo n.º 25
0
    def test_psnr(self):
        PSNR_LOG = self.LOG_FILENAME + '_psnr'

        cmd = "{psnr} {fmt} {ref} {dis} {w} {h} > {log}".format(
            psnr=required(ExternalProgram.psnr), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV,
            w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=PSNR_LOG
        )
        run_process(cmd, shell=True)
        score, scores = read_log(PSNR_LOG, "psnr")
        self.assertAlmostEqual(score, 30.7550639792, places=4)
        self.assertAlmostEqual(scores[0], 34.760779, places=4)
        self.assertAlmostEqual(scores[1], 31.88322, places=4)
Ejemplo n.º 26
0
 def test_2nd_moment(self):
     MOMENT_LOG = self.LOG_FILENAME + '_moment'
     print 'test 2nd moment...'
     cmd = "{moment} 2 {fmt} {dis} {w} {h} > {log}".format(
         moment=required(ExternalProgram.moment), fmt=self.YUV_FMT, dis=self.DIS_YUV,
         w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=MOMENT_LOG
     )
     run_process(cmd, shell=True)
     score, scores = read_log(MOMENT_LOG, "1stmoment")
     self.assertAlmostEquals(score, 61.332006624999984, places=4)
     score, scores = read_log(MOMENT_LOG, "2ndmoment")
     self.assertAlmostEquals(score, 4798.659574041666, places=4)
Ejemplo n.º 27
0
    def test_run_cleaning_cache_psnr(self):
        exe = config.ROOT + '/run_testing'
        cmd = "{exe} PSNR {dataset} --parallelize --cache-result --suppress-plot".format(
            exe=exe, dataset=self.dataset_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)

        exe = config.ROOT + '/python/script/run_cleaning_cache.py'
        cmd = "{exe} PSNR {dataset}".format(
            exe=exe, dataset=self.dataset_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)
Ejemplo n.º 28
0
    def test_run_cleaning_cache_psnr(self):
        exe = VmafConfig.root_path('run_testing')
        cmd = "{exe} PSNR {dataset} --parallelize --cache-result --suppress-plot".format(
            exe=exe, dataset=self.dataset_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)

        exe = VmafConfig.root_path('python', 'script', 'run_cleaning_cache.py')
        cmd = "{exe} PSNR {dataset}".format(
            exe=exe, dataset=self.dataset_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)
Ejemplo n.º 29
0
    def test_run_cleaning_cache_psnr(self):
        exe = VmafConfig.root_path('run_testing')
        cmd = "{exe} PSNR {dataset} --parallelize --cache-result --suppress-plot".format(
            exe=exe, dataset=self.dataset_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)

        exe = VmafConfig.root_path('python', 'script', 'run_cleaning_cache.py')
        cmd = "{exe} PSNR {dataset}".format(exe=exe,
                                            dataset=self.dataset_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)
Ejemplo n.º 30
0
 def test_ansnr(self):
     ANSNR_LOG = self.LOG_FILENAME + '_ansnr'
     print 'test ansnr...'
     cmd = "{vmaf} ansnr {fmt} {ref} {dis} {w} {h} > {log}".format(
         vmaf=required(ExternalProgram.vmaf), fmt=self.YUV_FMT, ref=self.REF_YUV, dis=self.DIS_YUV,
         w=self.YUV_WIDTH, h=self.YUV_HEIGHT, log=ANSNR_LOG
     )
     run_process(cmd, shell=True)
     score, scores = read_log(ANSNR_LOG, "ansnr")
     self.assertAlmostEquals(score, 23.5095715208, places=4)
     score, scores = read_log(ANSNR_LOG, "anpsnr")
     self.assertAlmostEquals(score, 34.164776875, places=4)
Ejemplo n.º 31
0
    def _open_ref_workfile(self, asset, fifo_mode):
        # For now, only works for YUV format -- all need is to copy from ref
        # file to ref workfile

        # only need to open ref workfile if the path is different from ref path
        assert asset.use_path_as_workpath is False and asset.ref_path != asset.ref_workfile_path

        # if fifo mode, mkfifo
        if fifo_mode:
            os.mkfifo(asset.ref_workfile_path)

        quality_width, quality_height = asset.quality_width_height
        yuv_type = asset.ref_yuv_type
        resampling_type = asset.resampling_type

        if yuv_type != 'notyuv':
            # in this case, for sure has ref_width_height
            width, height = asset.ref_width_height
            src_fmt_cmd = self._get_yuv_src_fmt_cmd(asset, height, width,
                                                    'ref')
        else:
            src_fmt_cmd = self._get_notyuv_src_fmt_cmd(asset, 'ref')

        workfile_yuv_type = self._get_workfile_yuv_type(asset)

        crop_cmd = self._get_crop_cmd(asset)
        pad_cmd = self._get_pad_cmd(asset)

        vframes_cmd, select_cmd = self._get_vframes_cmd(asset, 'ref')

        ffmpeg_cmd = '{ffmpeg} {src_fmt_cmd} -i {src} -an -vsync 0 ' \
                     '-pix_fmt {yuv_type} {vframes_cmd} -vf {select_cmd}{crop_cmd}{pad_cmd}scale={width}x{height} -f rawvideo ' \
                     '-sws_flags {resampling_type} -y {dst}'
        ffmpeg_cmd = ffmpeg_cmd.format(
            ffmpeg=VmafExternalConfig.get_and_assert_ffmpeg(),
            src=asset.ref_path,
            dst=asset.ref_workfile_path,
            width=quality_width,
            height=quality_height,
            src_fmt_cmd=src_fmt_cmd,
            crop_cmd=crop_cmd,
            pad_cmd=pad_cmd,
            yuv_type=workfile_yuv_type,
            resampling_type=resampling_type,
            vframes_cmd=vframes_cmd,
            select_cmd=select_cmd,
        )

        if self.logger:
            self.logger.info(ffmpeg_cmd)

        run_process(ffmpeg_cmd, shell=True)
Ejemplo n.º 32
0
    def call_vmafossexec(fmt,
                         w,
                         h,
                         ref_path,
                         dis_path,
                         model,
                         log_file_path,
                         disable_clip_score,
                         enable_transform_score,
                         phone_model,
                         disable_avx,
                         n_thread,
                         n_subsample,
                         psnr,
                         ssim,
                         ms_ssim,
                         ci,
                         exe=None,
                         logger=None):

        if exe is None:
            exe = required(ExternalProgram.vmafossexec)

        vmafossexec_cmd = "{exe} {fmt} {w} {h} {ref_path} {dis_path} {model} --log {log_file_path} --log-fmt xml --thread {n_thread} --subsample {n_subsample}" \
            .format(
            exe=exe,
            fmt=fmt,
            w=w,
            h=h,
            ref_path=ref_path,
            dis_path=dis_path,
            model=model,
            log_file_path=log_file_path,
            n_thread=n_thread,
            n_subsample=n_subsample)
        if disable_clip_score:
            vmafossexec_cmd += ' --disable-clip'
        if enable_transform_score or phone_model:
            vmafossexec_cmd += ' --enable-transform'
        if disable_avx:
            vmafossexec_cmd += ' --disable-avx'
        if psnr:
            vmafossexec_cmd += ' --psnr'
        if ssim:
            vmafossexec_cmd += ' --ssim'
        if ms_ssim:
            vmafossexec_cmd += ' --ms-ssim'
        if ci:
            vmafossexec_cmd += ' --ci'
        if logger:
            logger.info(vmafossexec_cmd)
        run_process(vmafossexec_cmd, shell=True)
Ejemplo n.º 33
0
    def test_run_vmaf_in_batch(self):
        line = 'yuv420p 576 324 {root}/resource/yuv/src01_hrc00_576x324.yuv ' \
               '{root}/resource/yuv/src01_hrc01_576x324.yuv'.format(root=config.ROOT)
        cmd = 'echo "{line}" > {batch_filename}'.format(
            line=line, batch_filename=self.batch_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)

        exe = config.ROOT + '/run_vmaf_in_batch'
        cmd = "{exe} {input} --parallelize >/dev/null 2>&1".format(
            exe=exe, input=self.batch_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)
Ejemplo n.º 34
0
    def test_run_vmaf_in_batch_ci(self):
        line = 'yuv420p 576 324 {root}/python/test/resource/yuv/src01_hrc00_576x324.yuv ' \
               '{root}/python/test/resource/yuv/src01_hrc01_576x324.yuv'.format(root=VmafConfig.root_path())
        cmd = 'echo "{line}" > {batch_filename}'.format(
            line=line, batch_filename=self.batch_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)

        exe = VmafConfig.root_path('run_vmaf_in_batch')
        cmd = "{exe} {input} --parallelize --ci >/dev/null 2>&1".format(
            exe=exe, input=self.batch_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)
Ejemplo n.º 35
0
    def test_run_vmaf_in_batch(self):
        line = 'yuv420p 576 324 {root}/python/test/resource/yuv/src01_hrc00_576x324.yuv ' \
               '{root}/python/test/resource/yuv/src01_hrc01_576x324.yuv'.format(root=VmafConfig.root_path())
        cmd = 'echo "{line}" > {batch_filename}'.format(
            line=line, batch_filename=self.batch_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)

        exe = VmafConfig.root_path('run_vmaf_in_batch')
        cmd = "{exe} {input} --parallelize >/dev/null 2>&1".format(
            exe=exe, input=self.batch_filename)
        ret = run_process(cmd, shell=True)
        self.assertEquals(ret, 0)
Ejemplo n.º 36
0
    def _open_ref_workfile(self, asset, fifo_mode):
        # For now, only works for YUV format -- all need is to copy from ref
        # file to ref workfile

        # only need to open ref workfile if the path is different from ref path
        assert asset.use_path_as_workpath is False and asset.ref_path != asset.ref_workfile_path

        # if fifo mode, mkfifo
        if fifo_mode:
            os.mkfifo(asset.ref_workfile_path)

        quality_width, quality_height = self._get_quality_width_height(asset)
        yuv_type = asset.ref_yuv_type
        resampling_type = self._get_resampling_type(asset)

        if yuv_type != 'notyuv':
            # in this case, for sure has ref_width_height
            width, height = asset.ref_width_height
            src_fmt_cmd = self._get_yuv_src_fmt_cmd(asset, height, width, 'ref')
        else:
            src_fmt_cmd = self._get_notyuv_src_fmt_cmd(asset, 'ref')

        workfile_yuv_type = self._get_workfile_yuv_type(asset)

        crop_cmd = self._get_crop_cmd(asset)
        pad_cmd = self._get_pad_cmd(asset)

        vframes_cmd, select_cmd = self._get_vframes_cmd(asset, 'ref')

        ffmpeg_cmd = '{ffmpeg} {src_fmt_cmd} -i {src} -an -vsync 0 ' \
                     '-pix_fmt {yuv_type} {vframes_cmd} -vf {select_cmd}{crop_cmd}{pad_cmd}scale={width}x{height} -f rawvideo ' \
                     '-sws_flags {resampling_type} -y {dst}'
        ffmpeg_cmd = ffmpeg_cmd.format(
            ffmpeg=VmafExternalConfig.get_and_assert_ffmpeg(),
            src=asset.ref_path,
            dst=asset.ref_workfile_path,
            width=quality_width,
            height=quality_height,
            src_fmt_cmd=src_fmt_cmd,
            crop_cmd=crop_cmd,
            pad_cmd=pad_cmd,
            yuv_type=workfile_yuv_type,
            resampling_type=resampling_type,
            vframes_cmd=vframes_cmd,
            select_cmd=select_cmd,
        )

        if self.logger:
            self.logger.info(ffmpeg_cmd)

        run_process(ffmpeg_cmd, shell=True)
Ejemplo n.º 37
0
    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)
Ejemplo n.º 38
0
 def test_run_vmaf(self):
     exe = VmafConfig.root_path('run_vmaf')
     line = 'yuv420p 576 324 {root}/python/test/resource/yuv/src01_hrc00_576x324.yuv ' \
            '{root}/python/test/resource/yuv/src01_hrc01_576x324.yuv'.format(root=VmafConfig.root_path())
     cmd = "{exe} {line} >/dev/null 2>&1".format(line=line, exe=exe)
     ret = run_process(cmd, shell=True)
     self.assertEquals(ret, 0)
Ejemplo n.º 39
0
 def test_run_testing_vmaf_raw_dataset(self):
     exe = VmafConfig.root_path('python', 'vmaf', 'script',
                                'run_testing.py')
     cmd = "{exe} VMAF {dataset} --parallelize --suppress-plot".format(
         exe=exe, dataset=self.raw_dataset_filename)
     ret = run_process(cmd, shell=True)
     self.assertEqual(ret, 0)
Ejemplo n.º 40
0
 def test_run_psnr(self):
     exe = VmafConfig.root_path('run_psnr')
     line = 'yuv420p 576 324 {root}/python/test/resource/yuv/src01_hrc00_576x324.yuv ' \
            '{root}/python/test/resource/yuv/src01_hrc01_576x324.yuv'.format(root=VmafConfig.root_path())
     cmd = "{exe} {line} >/dev/null 2>&1".format(line=line, exe=exe)
     ret = run_process(cmd, shell=True)
     self.assertEquals(ret, 0)
Ejemplo n.º 41
0
 def test_run_psnr(self):
     exe = config.ROOT + '/run_psnr'
     line = 'yuv420p 576 324 {root}/resource/yuv/src01_hrc00_576x324.yuv ' \
            '{root}/resource/yuv/src01_hrc01_576x324.yuv'.format(root=config.ROOT)
     cmd = "{exe} {line} >/dev/null 2>&1".format(line=line, exe=exe)
     ret = run_process(cmd, shell=True)
     self.assertEquals(ret, 0)
Ejemplo n.º 42
0
    def call_vmaf_feature(yuv_type, ref_path, dis_path, w, h, log_file_path, logger=None):

        # APPEND (>>) result (since _prepare_generate_log_file method has already created the file
        # and written something in advance).
        vmaf_feature_cmd = "{vmaf} all {yuv_type} {ref_path} {dis_path} {w} {h} >> {log_file_path}" \
            .format(
            vmaf=required(ExternalProgram.vmaf),
            yuv_type=yuv_type,
            ref_path=ref_path,
            dis_path=dis_path,
            w=w,
            h=h,
            log_file_path=log_file_path,
        )
        if logger:
            logger.info(vmaf_feature_cmd)
        run_process(vmaf_feature_cmd, shell=True)
Ejemplo n.º 43
0
 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=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)
Ejemplo n.º 44
0
    def call_vmaf_feature(yuv_type, ref_path, dis_path, w, h, log_file_path, logger=None):

        # APPEND (>>) result (since _prepare_generate_log_file method has already created the file
        # and written something in advance).
        vmaf_feature_cmd = "{vmaf} all {yuv_type} {ref_path} {dis_path} {w} {h} >> {log_file_path}" \
            .format(
            vmaf=required(ExternalProgram.vmaf),
            yuv_type=yuv_type,
            ref_path=ref_path,
            dis_path=dis_path,
            w=w,
            h=h,
            log_file_path=log_file_path,
        )
        if logger:
            logger.info(vmaf_feature_cmd)
        run_process(vmaf_feature_cmd, shell=True)
Ejemplo n.º 45
0
 def test_run_vmaf_training_raw_dataset(self):
     exe = VmafConfig.root_path('run_vmaf_training')
     cmd = "{exe} {dataset} {param} {param} {output} --parallelize --suppress-plot".format(
         exe=exe,
         dataset=self.raw_dataset_filename,
         param=self.param_filename,
         output=self.out_model_filepath)
     ret = run_process(cmd, shell=True)
     self.assertEquals(ret, 0)
Ejemplo n.º 46
0
 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)
Ejemplo n.º 47
0
 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)
Ejemplo n.º 48
0
 def test_run_testing_psnr(self):
     exe = VmafConfig.root_path('run_testing')
     cmd = "{exe} PSNR {dataset} --parallelize --suppress-plot".format(
         exe=exe, dataset=self.dataset_filename)
     ret = run_process(cmd, shell=True)
     self.assertEquals(ret, 0)