xref: /aosp_15_r20/external/deqp/modules/internal/ditImageCompareTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Internal Test Module
 * ---------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Image comparison tests.
 *//*--------------------------------------------------------------------*/

#include "ditImageCompareTests.hpp"
#include "tcuResource.hpp"
#include "tcuImageCompare.hpp"
#include "tcuFuzzyImageCompare.hpp"
#include "tcuImageIO.hpp"
#include "tcuTexture.hpp"
#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuRGBA.hpp"
#include "deFilePath.hpp"
#include "deClock.h"

namespace dit
{

using tcu::TestLog;

static const char *BASE_DIR = "internal/data/imagecompare";

static void loadImageRGBA8(tcu::TextureLevel &dst, const tcu::Archive &archive, const char *path)
{
    tcu::TextureLevel tmp;
    tcu::ImageIO::loadImage(tmp, archive, path);

    dst.setStorage(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), tmp.getWidth(),
                   tmp.getHeight());
    tcu::copy(dst, tmp);
}

class FuzzyComparisonMetricCase : public tcu::TestCase
{
public:
    FuzzyComparisonMetricCase(tcu::TestContext &testCtx, const char *name, const char *refImg, const char *cmpImg,
                              const float minBound, const float maxBound)
        : tcu::TestCase(testCtx, name, "")
        , m_refImg(refImg)
        , m_cmpImg(cmpImg)
        , m_minBound(minBound)
        , m_maxBound(maxBound)
    {
    }

    IterateResult iterate(void)
    {
        tcu::TextureLevel refImg;
        tcu::TextureLevel cmpImg;
        tcu::TextureLevel errorMask;
        tcu::FuzzyCompareParams params;
        float result         = 0.0f;
        uint64_t compareTime = 0;

        params.maxSampleSkip = 0;

        tcu::ImageIO::loadImage(refImg, m_testCtx.getArchive(), de::FilePath::join(BASE_DIR, m_refImg).getPath());
        tcu::ImageIO::loadImage(cmpImg, m_testCtx.getArchive(), de::FilePath::join(BASE_DIR, m_cmpImg).getPath());

        errorMask.setStorage(refImg.getFormat(), refImg.getWidth(), refImg.getHeight(), refImg.getDepth());

        {
            const uint64_t startTime = deGetMicroseconds();
            result                   = tcu::fuzzyCompare(params, refImg, cmpImg, errorMask);
            compareTime              = deGetMicroseconds() - startTime;
        }

        m_testCtx.getLog() << TestLog::Image("RefImage", "Reference Image", refImg)
                           << TestLog::Image("CmpImage", "Compare Image", cmpImg)
                           << TestLog::Image("ErrorMask", "Error Mask", errorMask);

        m_testCtx.getLog() << TestLog::Float("Result", "Result metric", "", QP_KEY_TAG_NONE, result)
                           << TestLog::Float("MinBound", "Minimum bound", "", QP_KEY_TAG_NONE, m_minBound)
                           << TestLog::Float("MaxBound", "Maximum bound", "", QP_KEY_TAG_NONE, m_maxBound)
                           << TestLog::Integer("CompareTime", "Comparison time", "us", QP_KEY_TAG_TIME, compareTime);

        {
            const bool isOk = de::inRange(result, m_minBound, m_maxBound);
            m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    isOk ? "Pass" : "Metric out of bounds");
        }

        return STOP;
    }

private:
    const std::string m_refImg;
    const std::string m_cmpImg;
    const float m_minBound;
    const float m_maxBound;
};

class BilinearCompareCase : public tcu::TestCase
{
public:
    BilinearCompareCase(tcu::TestContext &testCtx, const char *name, const char *refImg, const char *cmpImg,
                        const tcu::RGBA &threshold, bool expectedResult)
        : tcu::TestCase(testCtx, name, "")
        , m_refImg(refImg)
        , m_cmpImg(cmpImg)
        , m_threshold(threshold)
        , m_expectedResult(expectedResult)
    {
    }

    IterateResult iterate(void)
    {
        tcu::TextureLevel refImg;
        tcu::TextureLevel cmpImg;
        bool result;
        uint64_t compareTime = 0;

        loadImageRGBA8(refImg, m_testCtx.getArchive(), de::FilePath::join(BASE_DIR, m_refImg).getPath());
        loadImageRGBA8(cmpImg, m_testCtx.getArchive(), de::FilePath::join(BASE_DIR, m_cmpImg).getPath());

        {
            const uint64_t startTime = deGetMicroseconds();
            result      = tcu::bilinearCompare(m_testCtx.getLog(), "CompareResult", "Image comparison result", refImg,
                                               cmpImg, m_threshold, tcu::COMPARE_LOG_EVERYTHING);
            compareTime = deGetMicroseconds() - startTime;
        }

        m_testCtx.getLog() << TestLog::Integer("CompareTime", "Comparison time", "us", QP_KEY_TAG_TIME, compareTime);

        {
            const bool isOk = result == m_expectedResult;
            m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    isOk ? "Pass" : "Wrong comparison result");
        }

        return STOP;
    }

private:
    const std::string m_refImg;
    const std::string m_cmpImg;
    const tcu::RGBA m_threshold;
    const bool m_expectedResult;
};

class FuzzyComparisonMetricTests : public tcu::TestCaseGroup
{
public:
    FuzzyComparisonMetricTests(tcu::TestContext &testCtx)
        : tcu::TestCaseGroup(testCtx, "fuzzy_metric", "Fuzzy comparison metrics")
    {
    }

    void init(void)
    {
        addChild(
            new FuzzyComparisonMetricCase(m_testCtx, "identical", "cube_ref.png", "cube_ref.png", 0.0f, 0.000001f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "cube", "cube_ref.png", "cube_cmp.png", 0.0029f, 0.0031f));
        addChild(
            new FuzzyComparisonMetricCase(m_testCtx, "cube_2", "cube_2_ref.png", "cube_2_cmp.png", 0.0134f, 0.0140f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "cube_sphere", "cube_sphere_ref.png", "cube_sphere_cmp.png",
                                               0.0730f, 0.0801f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "cube_nmap", "cube_nmap_ref.png", "cube_nmap_cmp.png",
                                               0.0022f, 0.0025f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "cube_nmap_2", "cube_nmap_2_ref.png", "cube_nmap_2_cmp.png",
                                               0.0172f, 0.0189f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "earth_diffuse", "earth_diffuse_ref.png",
                                               "earth_diffuse_cmp.png", 0.0f, 0.00002f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "eath_texture", "earth_texture_ref.png",
                                               "earth_texture_cmp.png", 0.0002f, 0.0003f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "earth_spot", "earth_spot_ref.png", "earth_spot_cmp.png",
                                               0.0015f, 0.0018f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "earth_light", "earth_light_ref.png", "earth_light_cmp.png",
                                               1.7050f, 1.7070f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "lessThan0", "lessThan0-reference.png",
                                               "lessThan0-result.png", 0.0003f, 0.0004f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "cube_sphere_2", "cube_sphere_2_ref.png",
                                               "cube_sphere_2_cmp.png", 0.0207f, 0.0230f));
        addChild(new FuzzyComparisonMetricCase(m_testCtx, "earth_to_empty", "earth_spot_ref.png", "empty_256x256.png",
                                               54951.0f, 54955.0f));
    }
};

class BilinearCompareTests : public tcu::TestCaseGroup
{
public:
    BilinearCompareTests(tcu::TestContext &testCtx)
        : tcu::TestCaseGroup(testCtx, "bilinear_compare", "Bilinear Image Comparison Tests")
    {
    }

    void init(void)
    {
        addChild(new BilinearCompareCase(m_testCtx, "identical", "cube_ref.png", "cube_ref.png", tcu::RGBA(0, 0, 0, 0),
                                         true));
        addChild(new BilinearCompareCase(m_testCtx, "empty_to_white", "empty_256x256.png", "white_256x256.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "white_to_empty", "white_256x256.png", "empty_256x256.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(
            new BilinearCompareCase(m_testCtx, "cube", "cube_ref.png", "cube_cmp.png", tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "cube_2", "cube_2_ref.png", "cube_2_cmp.png", tcu::RGBA(7, 7, 7, 2),
                                         false));
        addChild(new BilinearCompareCase(m_testCtx, "cube_sphere", "cube_sphere_ref.png", "cube_sphere_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "cube_nmap", "cube_nmap_ref.png", "cube_nmap_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "cube_nmap_2", "cube_nmap_2_ref.png", "cube_nmap_2_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "earth_diffuse", "earth_diffuse_ref.png", "earth_diffuse_cmp.png",
                                         tcu::RGBA(20, 20, 20, 2), true));
        addChild(new BilinearCompareCase(m_testCtx, "eath_texture", "earth_texture_ref.png", "earth_texture_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "earth_spot", "earth_spot_ref.png", "earth_spot_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "earth_light", "earth_light_ref.png", "earth_light_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "lessThan0", "lessThan0-reference.png", "lessThan0-result.png",
                                         tcu::RGBA(36, 36, 36, 2), true));
        addChild(new BilinearCompareCase(m_testCtx, "cube_sphere_2", "cube_sphere_2_ref.png", "cube_sphere_2_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "earth_to_empty", "earth_spot_ref.png", "empty_256x256.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "texfilter", "texfilter_ref.png", "texfilter_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), true));
        addChild(new BilinearCompareCase(m_testCtx, "refract_vtx", "refract_vtx_ref.png", "refract_vtx_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), true));
        addChild(new BilinearCompareCase(m_testCtx, "refract_frag", "refract_frag_ref.png", "refract_frag_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), true));
        addChild(new BilinearCompareCase(m_testCtx, "lessthan_vtx", "lessthan_vtx_ref.png", "lessthan_vtx_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), true));
        addChild(new BilinearCompareCase(m_testCtx, "2_units_2d", "2_units_2d_ref.png", "2_units_2d_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "4_units_cube_vtx", "4_units_cube_ref.png", "4_units_cube_cmp.png",
                                         tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "texfilter_vtx_nearest", "texfilter_vtx_nearest_ref.png",
                                         "texfilter_vtx_nearest_cmp.png", tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "texfilter_vtx_linear", "texfilter_vtx_linear_ref.png",
                                         "texfilter_vtx_linear_cmp.png", tcu::RGBA(7, 7, 7, 2), false));
        addChild(new BilinearCompareCase(m_testCtx, "readpixels_msaa", "readpixels_ref.png", "readpixels_msaa.png",
                                         tcu::RGBA(1, 1, 1, 1), true));
    }
};

ImageCompareTests::ImageCompareTests(tcu::TestContext &testCtx)
    : tcu::TestCaseGroup(testCtx, "image_compare", "Image comparison tests")
{
}

ImageCompareTests::~ImageCompareTests(void)
{
}

void ImageCompareTests::init(void)
{
    addChild(new FuzzyComparisonMetricTests(m_testCtx));
    addChild(new BilinearCompareTests(m_testCtx));
}

} // namespace dit