Added QualityMAE with tests

modules/quality/include/opencv2/quality.hpp

@@ -11,5 +11,6 @@
 #include "quality/qualityssim.hpp"
 #include "quality/qualitygmsd.hpp"
 #include "quality/qualitybrisque.hpp"
+#include "quality/qualitymae.hpp"
 
 #endif

modules/quality/include/opencv2/quality/qualitymae.hpp

@@ -0,0 +1,78 @@
+#ifndef OPENCV_QUALITY_MAE_HPP
+#define OPENCV_QUALITY_MAE_HPP
+
+#include "qualitybase.hpp"
+
+
+namespace cv
+{
+
+namespace quality
+{
+
+/** @brief Flags to choose which algorithm MAE should use.
+ */
+enum MAEStatsFlags
+{
+    MAE_Max,
+    MAE_Mean
+};
+
+class CV_EXPORTS_W QualityMAE : public QualityBase
+{
+public:
+    /** @brief Computes MAE for reference images supplied in class constructor and provided comparison images
+    @param cmpImgs Comparison image(s)
+    @returns cv::Scalar with per-channel quality values.  Values range from 0 (best) to potentially max float (worst)
+    */
+    CV_WRAP Scalar compute( InputArray cmpImgs ) CV_OVERRIDE;
+
+    /** @brief Implements Algorithm::empty()  */
+    CV_WRAP bool empty() const CV_OVERRIDE { return _ref.empty() && QualityBase::empty(); }
+
+    /** @brief Implements Algorithm::clear()  */
+    CV_WRAP void clear() CV_OVERRIDE { _ref = _mat_type(); QualityBase::clear(); }
+
+    /**
+    @brief Create an object which calculates quality
+    @param ref input image to use as the reference for comparison
+    @param statsProc statistical method to apply on the error
+    */
+    CV_WRAP static Ptr<QualityMAE> create(InputArray ref, int statsProc = MAE_Mean);
+
+    /**
+    @brief static method for computing quality
+    @param ref reference image
+    @param cmp comparison image=
+    @param qualityMap output quality map, or cv::noArray()
+    @param statsProc which statistical method should be apply on the absolute error
+    @returns cv::Scalar with per-channel quality values.  Values range from 0 (best) to max float (worst)
+    */
+    CV_WRAP static Scalar compute( InputArray ref, InputArray cmp, OutputArray qualityMap, int statsProc = MAE_Mean );
+
+
+protected:
+
+    /** @brief Reference image, converted to internal mat type */
+    QualityBase::_mat_type _ref;
+
+    /** @brief What statistics analysis to apply on the absolute error */
+    int _flag;
+
+    /**
+    @brief Constructor
+    @param ref reference image, converted to internal type
+    @param statsProc statistical method to apply on the error
+    */
+    QualityMAE(QualityBase::_mat_type ref, int statsProc)
+        : _ref(std::move(ref)),
+          _flag(statsProc)
+    {}
+
+};
+
+} // quality
+
+} // cv
+
+#endif // OPENCV_QUALITY_MAE_HPP

modules/quality/src/qualitymae.cpp

@@ -0,0 +1,73 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "opencv2/quality/qualitymae.hpp"
+#include "opencv2/quality/quality_utils.hpp"
+
+namespace cv
+{
+
+namespace quality
+{
+
+using namespace quality_utils;
+
+
+// Static
+Ptr<QualityMAE> QualityMAE::create(InputArray ref, int statsProc)
+{
+    return Ptr<QualityMAE>(new QualityMAE(quality_utils::expand_mat<_mat_type>(ref), statsProc));
+}
+
+// Static
+Scalar QualityMAE::compute(InputArray ref, InputArray cmp, OutputArray qualityMap, int statsProc)
+{
+    CV_Assert_3(ref.channels() <= 4,
+                cmp.channels() <= 4,
+                (statsProc == MAE_Max) || (statsProc == MAE_Mean) );
+
+    _mat_type err;
+    int wdepth = std::max(std::max(ref.depth(), cmp.depth()), CV_32F);
+    int cn = ref.channels();
+    int wtype = CV_MAKETYPE(wdepth, cn);
+
+    absdiff(extract_mat<_mat_type>(ref, wtype), extract_mat<_mat_type>(cmp, wtype), err);
+
+    if(qualityMap.needed())
+        qualityMap.assign(statsProc == MAE_Max ? err : err.clone());
+
+    if(statsProc == MAE_Mean)
+    {
+        return mean(err);
+    }
+
+    Scalar scores;
+    _mat_type tmp = err.reshape(err.channels(), 1);
+
+    reduce(tmp, tmp, 1, REDUCE_MAX, wdepth);
+
+    tmp.convertTo(Mat(tmp.size(), CV_64FC(cn), scores.val), CV_64F);
+
+    return scores;
+}
+
+// Not static
+Scalar QualityMAE::compute( InputArray cmpImg )
+{
+    CV_Assert(cmpImg.isMat() || cmpImg.isUMat() || cmpImg.isMatx());
+
+    if(cmpImg.empty())
+        return Scalar();
+
+    // If the input is a set of images.
+    _mat_type cmp = extract_mat<_mat_type>(cmpImg, std::max(cmpImg.depth(), CV_32F));
+
+    return QualityMAE::compute(this->_ref, cmp, this->_qualityMap, this->_flag);
+}
+
+
+} // quality
+
+} // cv

modules/quality/test/test_mae.cpp

@@ -0,0 +1,66 @@
+#include "test_precomp.hpp"
+
+#define TEST_CASE_NAME CV_Quality_MAE
+
+namespace opencv_test
+{
+namespace quality_test
+{
+
+const cv::Scalar
+    MAE_MAX_EXPECTED_1 = { 203. },
+    MAE_MEAN_EXPECTED_1 = { 33.5824 },
+    MAE_MAX_EXPECTED_2 = { 138., 145., 156. },
+    MAE_MEAN_EXPECTED_2 = { 5.7918, 6.0645, 5.5609}
+    ;
+
+// static method
+TEST(TEST_CASE_NAME, static_max )
+{
+    // Max
+    cv::Mat qMat = {};
+    quality_expect_near(quality::QualityMAE::compute(get_testfile_1a(), get_testfile_1a(), qMat, quality::MAE_Max), cv::Scalar(0.)); // ref vs ref == 0
+    check_quality_map(qMat);
+}
+
+// static method
+TEST(TEST_CASE_NAME, static_mean )
+{
+    // Mean
+    cv::Mat qMat = {};
+    quality_expect_near(quality::QualityMAE::compute(get_testfile_1a(), get_testfile_1a(), qMat, quality::MAE_Mean), cv::Scalar(0.)); // ref vs ref == 0
+    check_quality_map(qMat);
+}
+
+// single channel, with and without opencl
+TEST(TEST_CASE_NAME, single_channel_max )
+{
+    auto fn = []() { quality_test(quality::QualityMAE::create(get_testfile_1a(), quality::MAE_Max), get_testfile_1b(), MAE_MAX_EXPECTED_1); };
+
+    OCL_OFF( fn() );
+    OCL_ON( fn() );
+}
+
+// single channel, with and without opencl
+TEST(TEST_CASE_NAME, single_channel_mean )
+{
+    auto fn = []() { quality_test(quality::QualityMAE::create(get_testfile_1a(), quality::MAE_Mean), get_testfile_1b(), MAE_MEAN_EXPECTED_1); };
+
+    OCL_OFF( fn() );
+    OCL_ON( fn() );
+}
+
+// multi-channel max
+TEST(TEST_CASE_NAME, multi_channel_max)
+{
+    quality_test(quality::QualityMAE::create(get_testfile_2a(), quality::MAE_Max), get_testfile_2b(), MAE_MAX_EXPECTED_2);
+}
+
+// multi-channel mean
+TEST(TEST_CASE_NAME, multi_channel_mean)
+{
+    quality_test(quality::QualityMAE::create(get_testfile_2a(), quality::MAE_Mean), get_testfile_2b(), MAE_MEAN_EXPECTED_2);
+}
+
+} // namespace quality_test
+} // namespace opencv_test