qualitypsnr.hpp

// 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.
 
#ifndef OPENCV_QUALITY_QUALITYPSNR_HPP
#define OPENCV_QUALITY_QUALITYPSNR_HPP
 
#include <limits>   // numeric_limits
#include "qualitybase.hpp"
#include "qualitymse.hpp"
 
namespace cv
{
namespace quality
{
 
class CV_EXPORTS_W QualityPSNR
    : public QualityBase {
 
public:
 
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900/*MSVS 2015*/)
    static constexpr double MAX_PIXEL_VALUE_DEFAULT = 255.;
#else
    // support MSVS 2013
    static const int MAX_PIXEL_VALUE_DEFAULT = 255;
#endif
 
    CV_WRAP static Ptr<QualityPSNR> create( InputArray ref, double maxPixelValue = QualityPSNR::MAX_PIXEL_VALUE_DEFAULT )
    {
        return Ptr<QualityPSNR>(new QualityPSNR(QualityMSE::create(ref), maxPixelValue));
    }
 
    CV_WRAP cv::Scalar compute( InputArray cmp ) CV_OVERRIDE
    {
        auto result = _qualityMSE->compute( cmp );
        _qualityMSE->getQualityMap(_qualityMap);  // copy from internal obj to this obj
        return _mse_to_psnr(
            result
            , _maxPixelValue
        );
    }
 
    CV_WRAP bool empty() const CV_OVERRIDE { return _qualityMSE->empty() && QualityBase::empty(); }
 
    CV_WRAP void clear() CV_OVERRIDE { _qualityMSE->clear(); QualityBase::clear(); }
 
    CV_WRAP static cv::Scalar compute( InputArray ref, InputArray cmp, OutputArray qualityMap, double maxPixelValue = QualityPSNR::MAX_PIXEL_VALUE_DEFAULT)
    {
        return _mse_to_psnr(
            QualityMSE::compute(ref, cmp, qualityMap)
            , maxPixelValue
        );
    }
 
    CV_WRAP double getMaxPixelValue() const { return _maxPixelValue; }
 
    CV_WRAP void setMaxPixelValue(double val) { this->_maxPixelValue = val; }
 
protected:
 
    Ptr<QualityMSE> _qualityMSE;
    double _maxPixelValue = QualityPSNR::MAX_PIXEL_VALUE_DEFAULT;
 
    QualityPSNR( Ptr<QualityMSE> qualityMSE, double maxPixelValue )
        : _qualityMSE(std::move(qualityMSE))
        , _maxPixelValue(maxPixelValue)
    {}
 
    // convert mse to psnr
    static double _mse_to_psnr(double mse, double max_pixel_value)
    {
        return (mse == 0.)
            ? std::numeric_limits<double>::infinity()
            : 10. * std::log10((max_pixel_value * max_pixel_value) / mse)
            ;
    }
 
    // convert scalar of mses to psnrs
    static cv::Scalar _mse_to_psnr(cv::Scalar mse, double max_pixel_value)
    {
        for (int i = 0; i < mse.rows; ++i)
            mse(i) = _mse_to_psnr(mse(i), max_pixel_value);
        return mse;
    }
 
};    // QualityPSNR
}   // quality
}   // cv
#endif