Initial autostretch

rawimage.cpp

@@ -14,6 +14,8 @@ RawImage::ImgType CV2Type(int cvtype)
         return RawImage::FLOAT32;
     case CV_8UC3:
         return RawImage::UINT8C3;
+    case CV_8UC4:
+        return RawImage::UINT8C4;
     case CV_16UC3:
         return RawImage::UINT16C3;
     case CV_32FC3:
@@ -35,6 +37,8 @@ int Type2CV(RawImage::ImgType type)
         return CV_32F;
     case RawImage::UINT8C3:
         return CV_8UC3;
+    case RawImage::UINT8C4:
+        return CV_8UC4;
     case RawImage::UINT16C3:
         return CV_16UC3;
     case RawImage::FLOAT32C3:
@@ -58,29 +62,56 @@ RawImage::RawImage(int w, int h, ImgType type)
 RawImage::RawImage(cv::Mat &img)
 {
     m_img = img;
+    calcStats();
 }
 
 RawImage::RawImage(const RawImage &d)
 {
     d.m_img.copyTo(m_img);
+    m_mean = d.m_mean;
+    m_stdDev = d.m_stdDev;
+    m_median = d.m_median;
+    m_min = d.m_min;
+    m_max = d.m_max;
 }
 
 RawImage::RawImage(const QImage &img)
 {
-    QImage tmp = img.convertToFormat(QImage::Format_RGB888);
-    m_img.create(img.height(), img.width(), CV_8UC3);
+    if(img.format() == QImage::Format_RGB32)
+    {
+        m_img.create(img.height(), img.width(), CV_8UC4);
+        for(int i=0; i<img.height(); i++)
+            std::memcpy(m_img.ptr(i), img.scanLine(i), img.width()*4);
+    }
+    else
+    {
+        QImage tmp = img.convertToFormat(QImage::Format_RGB888);
+        m_img.create(img.height(), img.width(), CV_8UC3);
 
-    for(int i=0; i<tmp.height(); i++)
-        std::memcpy(m_img.ptr(i), tmp.scanLine(i), tmp.width()*3);
+        for(int i=0; i<tmp.height(); i++)
+            std::memcpy(m_img.ptr(i), tmp.scanLine(i), tmp.width()*3);
+    }
+    calcStats();
 }
 
 bool RawImage::imageStats(double *mean, double *stdDev, double *median, double *min, double *max) const
+{
+    if(mean)*mean = m_mean;
+    if(stdDev)*stdDev = m_stdDev;
+    if(median)*median = m_median;
+    if(min)*min = m_min;
+    if(max)*max = m_max;
+
+    return true;
+}
+
+void RawImage::calcStats()
 {
     cv::Scalar meanS, stdDevS;
 
     qDebug() << m_img.type();
     cv::meanStdDev(m_img, meanS, stdDevS);
-    if(min && max)cv::minMaxIdx(m_img, min, max);
+    cv::minMaxIdx(m_img, &m_min, &m_max);
 
     int histSize = 256;
     if(m_img.type() == CV_16U || m_img.type() == CV_32F)histSize = 65536;
@@ -89,24 +120,32 @@ bool RawImage::imageStats(double *mean, double *stdDev, double *median, double *
     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];
+    m_mean = meanS[0];
+    m_stdDev = stdDevS[0];
     size_t halfImageSize = size()/2;
-    if(median)
+    size_t medianSum = 0;
+    for(int i=0; i < histSize; i++)
     {
-        size_t medianSum = 0;
-        for(int i=0; i < histSize; i++)
+        medianSum += hist.at<float>(0, i);
+        if(medianSum >= halfImageSize)
         {
-            medianSum += hist.at<float>(0, i);
-            if(medianSum >= halfImageSize)
-            {
-                *median = i;
-                break;
-            }
+            m_median = i;
+            break;
+        }
+    }
+    cv::Mat absDev = cv::abs(m_img-m_median);
+    cv::Mat madHist;
+    medianSum = 0;
+    cv::calcHist(&absDev, 1, nullptr, cv::Mat(), madHist, 1, &histSize, ranges);
+    for(int i=0; i < histSize; i++)
+    {
+        medianSum += madHist.at<float>(0, i);
+        if(medianSum >= halfImageSize)
+        {
+            m_mad = i;
+            break;
         }
     }
-
-    return true;
 }
 
 void RawImage::rect(int &x, int &y, int w, int h, std::vector<double> &r) const
@@ -187,3 +226,13 @@ const void *RawImage::data() const
 {
     return m_img.ptr();
 }
+
+float RawImage::stretchFactor() const
+{
+
+}
+
+double RawImage::MAD() const
+{
+    return m_mad;
+}