Reworked RawImage class to use OpenCV

rawimage.cpp

@@ -0,0 +1,171 @@
+#include "rawimage.h"
+#include <QDebug>
+#include <opencv2/highgui.hpp>
+
+RawImage::ImgType CV2Type(int cvtype)
+{
+    switch (cvtype)
+    {
+    case CV_8U:
+        return RawImage::UINT8;
+    case CV_16U:
+        return RawImage::UINT16;
+    case CV_32F:
+        return RawImage::FLOAT32;
+    default:
+        return RawImage::UNKNOWN;
+    }
+}
+
+int Type2CV(RawImage::ImgType type)
+{
+    switch (type)
+    {
+    case RawImage::UINT8:
+        return CV_8U;
+    case RawImage::UINT16:
+        return CV_16U;
+    case RawImage::FLOAT32:
+        return CV_32F;
+    case RawImage::UNKNOWN:
+        return CV_8S;
+    }
+}
+
+RawImage::RawImage()
+{
+}
+
+RawImage::RawImage(int w, int h, ImgType type)
+{
+    m_img.create(h, w, Type2CV(type));
+}
+
+RawImage::RawImage(const RawImage &d)
+{
+    d.m_img.copyTo(m_img);
+}
+
+bool RawImage::imageStats(double *mean, double *stdDev, double *median, double *min, double *max) const
+{
+    cv::Scalar meanS, stdDevS;
+
+    qDebug() << m_img.type();
+    cv::meanStdDev(m_img, meanS, stdDevS);
+    if(min && max)cv::minMaxIdx(m_img, min, max);
+
+    int histSize = 256;
+    if(m_img.type() == CV_16U || m_img.type() == CV_32F)histSize = 65536;
+    float range[] = {0, (float)histSize};
+    const float *ranges[] = {range};
+    cv::Mat hist;
+    cv::calcHist(&m_img, 1, nullptr, cv::Mat(), hist, 1, &histSize, ranges);
+
+    if(mean)*mean = meanS[0];
+    if(stdDev)*stdDev = stdDevS[0];
+    size_t halfImageSize = size()/2;
+    if(median)
+    {
+        size_t medianSum = 0;
+        for(int i=0; i < histSize; i++)
+        {
+            medianSum += hist.at<float>(0, i);
+            if(medianSum >= halfImageSize)
+            {
+                *median = i;
+                break;
+            }
+        }
+    }
+
+    return true;
+}
+
+void RawImage::rect(int &x, int &y, int w, int h, std::vector<double> &r) const
+{
+    r.resize(w*h);
+    x -= w/2;
+    y -= h/2;
+    if(x<0)x = 0;
+    if(y<0)y = 0;
+    if(x+w >= m_img.cols)x = m_img.cols-w;
+    if(y+h >= m_img.rows)y = m_img.rows-h;
+    cv::Mat roiImg(m_img, cv::Rect(x, y, w, h));
+    cv::Mat doubleMat;
+    roiImg.convertTo(doubleMat, CV_64F);
+    r = std::vector<double>(doubleMat.begin<double>(), doubleMat.end<double>());
+}
+
+int RawImage::findPeaks(double background, double distance, std::vector<Peak> &peaks) const
+{
+    std::vector<std::vector<cv::Point>> contours;
+
+    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(distance, distance));
+
+    cv::Mat mask, dilate, locMax, result;
+    cv::dilate(m_img, dilate, kernel);
+    cv::compare(m_img, dilate, locMax, cv::CMP_GE);
+    cv::compare(m_img, cv::Scalar(background), mask, cv::CMP_GT);
+    cv::bitwise_and(locMax, mask, result);
+
+    cv::findContours(result, contours, cv::noArray(), cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
+    peaks.reserve(contours.size());
+    for(auto contour : contours)
+    {
+        peaks.push_back(Peak(1, contour[0].x, contour[0].y));
+    }
+
+    return peaks.size();
+}
+
+RawImage* RawImage::medianFilter() const
+{
+    RawImage *ret = new RawImage();
+    cv::medianBlur(m_img, ret->m_img, 3);
+    return ret;
+}
+
+void RawImage::quarter()
+{
+
+}
+
+uint32_t RawImage::width() const
+{
+    return m_img.cols;
+}
+
+uint32_t RawImage::height() const
+{
+    return m_img.rows;
+}
+
+uint32_t RawImage::size() const
+{
+    return width()*height();
+}
+
+RawImage::ImgType RawImage::type() const
+{
+    switch(m_img.type())
+    {
+    case CV_8U:
+        return UINT8;
+    case CV_16U:
+        return UINT16;
+    case CV_32F:
+        return FLOAT32;
+    default:
+        return UNKNOWN;
+    }
+}
+
+void* RawImage::data()
+{
+    return m_img.ptr();
+}
+
+const void *RawImage::data() const
+{
+    return m_img.ptr();
+}