opencv
diff --git a/‎modules/quality/CMakeLists.txt
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎modules/quality/CMakeLists.txt
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎modules/quality/README.md
Copy file name to clipboard
+9-5Lines changed: 9 additions & 5 deletions b/‎modules/quality/README.md
Copy file name to clipboard
+9-5Lines changed: 9 additions & 5 deletions
diff --git a/‎modules/quality/doc/quality.bib
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions b/‎modules/quality/doc/quality.bib
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions
diff --git a/‎modules/quality/include/opencv2/quality/libsvm/svm.hpp
Copy file name to clipboard b/‎modules/quality/include/opencv2/quality/libsvm/svm.hpp
Copy file name to clipboard
diff --git a/‎modules/quality/include/opencv2/quality/quality_utils.hpp
Copy file name to clipboard
+85-18Lines changed: 85 additions & 18 deletions b/‎modules/quality/include/opencv2/quality/quality_utils.hpp
Copy file name to clipboard
+85-18Lines changed: 85 additions & 18 deletions
diff --git a/‎modules/quality/include/opencv2/quality/qualitybrisque.hpp
Copy file name to clipboard
+36-29Lines changed: 36 additions & 29 deletions b/‎modules/quality/include/opencv2/quality/qualitybrisque.hpp
Copy file name to clipboard
+36-29Lines changed: 36 additions & 29 deletions
@@ -1,5 +1,5 @@
 set(the_description "Image Quality Analysis API")
-ocv_define_module(quality opencv_core opencv_imgproc WRAP python)
-ocv_add_testdata(testdata/ contrib/quality
-    FILES_MATCHING PATTERN "*.dat"
+ocv_define_module(quality opencv_core opencv_imgproc opencv_ml WRAP python)
+ocv_add_testdata(samples/ contrib/quality
+    FILES_MATCHING PATTERN "*.yml"
 )
@@ -1,3 +1,6 @@
+//! @addtogroup quality
+//! @{
+
 Quality API, Image Quality Analysis
 =======================================
 
@@ -57,10 +60,9 @@ Quick Start/Usage
 
 ```cpp
     #include <opencv2/quality.hpp>
-    cv::Mat img;
-    // check testdata subdirectory
-    cv::String model_path = "testdata/brisque_allmodel.dat"; // path to the trained model
-    cv::String range_path = "testdata/brisque_allrange.dat"; // path to range file
+    cv::Mat img = cv::imread("/path/to/my_image.bmp"); // path to the image to evaluate
+    cv::String model_path = "path/to/brisque_model_live.yml"; // path to the trained model
+    cv::String range_path = "path/to/brisque_range_live.yml"; // path to range file
     /* compute BRISQUE quality score via static method */
     cv::Scalar result_static = quality::QualityBRISQUE::compute(img,
 model_path, range_path);
@@ -118,4 +120,6 @@ Each implemented algorithm shall:
 To Do
 -----------------------------------------
 - Document the output quality maps for each algorithm
-- Investigate precision loss with cv::Filter2D + UMat + CV_32F + OCL for GMSD
+- Investigate precision loss with cv::Filter2D + UMat + CV_32F + OCL for GMSD
+
+//! @}
@@ -15,4 +15,20 @@ @misc{Mittal2_software
   author={A. {Mittal} and A. K. {Moorthy} and A. C. {Bovik}},
   howpublished={\url{https://live.ece.utexas.edu/research/quality/BRISQUE_release.zip}},
   year={2011},
+}
+
+@article{Ponomarenko,
+  title={TID2008 - A Database for Evaluation of Full-Reference Visual Quality Assessment Metrics},
+  author={N. {Ponomarenko}, V. {Lukin}, A. {Zelensky}, K. {Egiazarian}, M. {Carli}, F. {Battisti}},
+  journal={Advances of Modern Radioelectronics},
+  volume={10},
+  pages={30-45},
+  year={2009},
+}
+
+@misc{Sheikh,
+  title={LIVE Image Quality Assessment Database Release 2},
+  author={H.R. {Sheikh}, Z. {Wang}, L. {Cormack} and A.C. {Bovik}},
+  howpublished={\url{https://live.ece.utexas.edu/research/quality}},
+  year={2005},
 }
@@ -18,6 +18,41 @@ namespace quality_utils
 // default type of matrix to expand to
 static CV_CONSTEXPR const int EXPANDED_MAT_DEFAULT_TYPE = CV_32F;
 
+// convert input array to vector of specified mat types.  set type == -1 to preserve existing type
+template <typename R>
+inline std::vector<R> extract_mats( InputArrayOfArrays arr, const int type = -1 )
+{
+    std::vector<R> result = {};
+    std::vector<UMat> umats = {};
+    std::vector<Mat> mats = {};
+
+    if (arr.isUMatVector())
+        arr.getUMatVector(umats);
+    else if (arr.isUMat())
+        umats.emplace_back(arr.getUMat());
+    else if (arr.isMatVector())
+        arr.getMatVector(mats);
+    else if (arr.isMat())
+        mats.emplace_back(arr.getMat());
+    else
+        CV_Error(Error::StsNotImplemented, "Unsupported input type");
+
+    // convert umats, mats to desired type
+    for (auto& umat : umats)
+    {
+        result.emplace_back(R{});
+        umat.convertTo(result.back(), ( type != -1 ) ? type : umat.type() );
+    }
+
+    for (auto& mat : mats)
+    {
+        result.emplace_back(R{});
+        mat.convertTo(result.back(), (type != -1) ? type : mat.type() );
+    }
+
+    return result;
+}
+
 // expand matrix to target type
 template <typename OutT, typename InT>
 inline OutT expand_mat(const InT& src, int TYPE_DEFAULT = EXPANDED_MAT_DEFAULT_TYPE)
@@ -46,26 +81,10 @@ template <typename R>
 inline std::vector<R> expand_mats(InputArrayOfArrays arr, int TYPE_DEFAULT = EXPANDED_MAT_DEFAULT_TYPE)
 {
     std::vector<R> result = {};
-    std::vector<UMat> umats = {};
-    std::vector<Mat> mats = {};
-
-    if (arr.isUMatVector())
-        arr.getUMatVector(umats);
-    else if (arr.isUMat())
-        umats.emplace_back(arr.getUMat());
-    else if (arr.isMatVector())
-        arr.getMatVector(mats);
-    else if (arr.isMat())
-        mats.emplace_back(arr.getMat());
-    else
-        CV_Error(Error::StsNotImplemented, "Unsupported input type");
-
-    // convert umats, mats to expanded internal type
-    for (auto& umat : umats)
-        result.emplace_back(expand_mat<R>(umat, TYPE_DEFAULT ));
 
+    auto mats = extract_mats<R>(arr, -1);
     for (auto& mat : mats)
-        result.emplace_back(expand_mat<R>(mat, TYPE_DEFAULT ));
+        result.emplace_back(expand_mat<R>(mat, TYPE_DEFAULT));
 
     return result;
 }
@@ -87,6 +106,54 @@ inline cv::Scalar mse_to_psnr(cv::Scalar mse, double max_pixel_value)
     return mse;
 }
 
+// return mat of observed min/max pair per column
+//  row 0:  min per column
+//  row 1:  max per column
+// template <typename T>
+inline cv::Mat get_column_range( const cv::Mat& data )
+{
+    CV_Assert(data.channels() == 1);
+    CV_Assert(data.rows > 0);
+
+    cv::Mat result( cv::Size( data.cols, 2 ), data.type() );
+
+    auto
+        row_min = result.row(0)
+        , row_max = result.row(1)
+        ;
+
+    // set initial min/max
+    data.row(0).copyTo(row_min);
+    data.row(0).copyTo(row_max);
+
+    for (int y = 1; y < data.rows; ++y)
+    {
+        auto row = data.row(y);
+        cv::min(row,row_min, row_min);
+        cv::max(row, row_max, row_max);
+    }
+    return result;
+}   // get_column_range
+
+// linear scale of each column from min to max
+//  range is column-wise pair of observed min/max.  See get_column_range
+template <typename T>
+inline void scale( cv::Mat& mat, const cv::Mat& range, const T min, const T max )
+{
+    // value = lower + (upper - lower) * (value - feature_min[index]) / (feature_max[index] - feature_min[index]);
+    // where [lower] = lower bound, [upper] = upper bound
+
+    for (int y = 0; y < mat.rows; ++y)
+    {
+        auto row = mat.row(y);
+        auto row_min = range.row(0);
+        auto row_max = range.row(1);
+
+        for (int x = 0; x < mat.cols; ++x)
+            row.at<T>(x) = min + (max - min) * (row.at<T>(x) - row_min.at<T>(x) ) / (row_max.at<T>(x) - row_min.at<T>(x));
+    }
+}
+
 }   // quality_utils
 }   // quality
 }   // cv
 
@@ -6,69 +6,76 @@
 #define OPENCV_QUALITY_QUALITYBRISQUE_HPP
 
 #include "qualitybase.hpp"
+#include "opencv2/ml.hpp"
 
 namespace cv
 {
 namespace quality
 {
 
-/** @brief Custom deleter for QualityBRISQUE internal data */
-struct _QualityBRISQUEDeleter
-{
-    void operator()(void*) const;
-};
-
 /**
-@brief BRISQUE (Blind/Referenceless Image Spatial Quality Evaluator) is a type of No Reference
-Image Quality Assessment. It measures score based on extracting Natural Scene Satistics (https://en.wikipedia.org/wiki/Scene_statistics)
-and calculating feature vectors. The current implementation uses trained model on TID 2008 Database (https://www.ponomarenko.info/tid2008.htm).
-@cite Mittal2 for original paper and @cite Mittal2_software for original implementation
+@brief BRISQUE (Blind/Referenceless Image Spatial Quality Evaluator) is a No Reference Image Quality Assessment (NR-IQA) algorithm.
+
+BRISQUE computes a score based on extracting Natural Scene Statistics (https://en.wikipedia.org/wiki/Scene_statistics)
+and calculating feature vectors. See Mittal et al. @cite Mittal2 for original paper and original implementation @cite Mittal2_software .
+
+A trained model is provided in the /samples/ directory and is trained on the LIVE-R2 database @cite Sheikh as in the original implementation.
+When evaluated against the TID2008 database @cite Ponomarenko , the SROCC is -0.8424 versus the SROCC of -0.8354 in the original implementation.
+C++ code for the BRISQUE LIVE-R2 trainer and TID2008 evaluator are also provided in the /samples/ directory.
 */
 class CV_EXPORTS_W QualityBRISQUE : public QualityBase {
 public:
 
     /** @brief Computes BRISQUE quality score for input images
     @param imgs Images for which to compute quality (should be passed as a vector<Mat> in C++ and list of images in Python)
     @returns Score (averaged over individual scores of all images) ranging from 0 to 100
-    (0 denotes the best quality and 100 denotes the poorest quality). The format of the score is: {score, 0., 0., 0.}
+    (0 denotes the best quality and 100 denotes the worst quality). The format of the score is: {score, 0., 0., 0.}
     */
     CV_WRAP cv::Scalar compute( InputArrayOfArrays imgs ) CV_OVERRIDE;
 
     /**
     @brief Create an object which calculates quality
-    @param model_file_path cv::String which contains a path to the BRISQUE model data.  If empty, attempts to load from ${OPENCV_DIR}/testdata/contrib/quality/brisque_allmodel.dat
-    @param range_file_path cv::String which contains a path to the BRISQUE range data.  If empty, attempts to load from ${OPENCV_DIR}/testdata/contrib/quality/brisque_allrange.dat
+    @param model_file_path cv::String which contains a path to the BRISQUE model data.  If empty, attempts to load from ${OPENCV_DIR}/testdata/contrib/quality/brisque_model_live.yml
+    @param range_file_path cv::String which contains a path to the BRISQUE range data.  If empty, attempts to load from ${OPENCV_DIR}/testdata/contrib/quality/brisque_range_live.yml
     */
     CV_WRAP static Ptr<QualityBRISQUE> create( const cv::String& model_file_path = "", const cv::String& range_file_path = "" );
 
-    // CV_WRAP static cv::Scalar compute_single( const Mat& cmpImg, const cv::String& model_file_path, const cv::String& range_file_path );
+    /**
+    @brief Create an object which calculates quality
+    @param model cv::Ptr<cv::ml::SVM> which contains a loaded BRISQUE model
+    @param range cv::Mat which contains BRISQUE range data
+    */
+    CV_WRAP static Ptr<QualityBRISQUE> create( const cv::Ptr<cv::ml::SVM>& model, const cv::Mat& range );
+
     /**
     @brief static method for computing quality
-    @param imgs image(s) for which to compute quality (passed as vector<Mat> in C++ and as list of images in Python)
-    @param model_file_path cv::String which contains a path to the BRISQUE model data.  If empty, attempts to load from ${OPENCV_DIR}/testdata/contrib/quality/brisque_allmodel.dat
-    @param range_file_path cv::String which contains a path to the BRISQUE range data.  If empty, attempts to load from ${OPENCV_DIR}/testdata/contrib/quality/brisque_allrange.dat
+    @param imgs image(s) for which to compute quality (passed as Mat or vector<Mat> in C++ and as list of images in Python)
+    @param model_file_path cv::String which contains a path to the BRISQUE model data.  If empty, attempts to load from ${OPENCV_DIR}/testdata/contrib/quality/brisque_model_live.yml
+    @param range_file_path cv::String which contains a path to the BRISQUE range data.  If empty, attempts to load from ${OPENCV_DIR}/testdata/contrib/quality/brisque_range_live.yml
     @returns cv::Scalar result of format {std::double score, 0., 0., 0.}. Score ranges from 0 to 100 (100 means worst and 0 means best)
     */
     CV_WRAP static cv::Scalar compute( InputArrayOfArrays imgs, const cv::String& model_file_path, const cv::String& range_file_path );
 
-    /* brief destructor */
-    ~QualityBRISQUE() CV_OVERRIDE;
+    /**
+    @brief static method for computing image features used by the BRISQUE algorithm
+    @param img image (BGR(A) or grayscale) for which to compute features
+    @param features output row vector of features to cv::Mat or cv::UMat
+    */
+    CV_WRAP static void computeFeatures(InputArray img, OutputArray features);
 
 protected:
 
+    cv::Ptr<cv::ml::SVM> _model = nullptr;
+    cv::Mat _range;
+
     /** @brief Internal constructor */
     QualityBRISQUE( const cv::String& model_file_path, const cv::String& range_file_path );
 
-    // type-erased svmmodel
-    void* _svm_model = nullptr;
-
-    static constexpr const std::size_t _SVM_RANGE_SIZE = 36U;
-    using _svm_range_type = float;
-
-    std::array<_svm_range_type, _SVM_RANGE_SIZE>
-        _svm_range_min = {}
-        , _svm_range_max = {}
-    ;
+    /** @brief Internal constructor */
+    QualityBRISQUE(const cv::Ptr<cv::ml::SVM>& model, const cv::Mat& range )
+        : _model{ model }
+        , _range{ range }
+    {}
 
 };  // QualityBRISQUE
 }   // quality
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`set(the_description "Image Quality Analysis API")`
`2`		`-ocv_define_module(quality opencv_core opencv_imgproc WRAP python)`
`3`		`-ocv_add_testdata(testdata/ contrib/quality`
`4`		`- FILES_MATCHING PATTERN "*.dat"`
	`2`	`+ocv_define_module(quality opencv_core opencv_imgproc opencv_ml WRAP python)`
	`3`	`+ocv_add_testdata(samples/ contrib/quality`
	`4`	`+ FILES_MATCHING PATTERN "*.yml"`
`5`	`5`	`)`