Refractor loading FITS so it can load RGB images

loadrunable.cpp

@@ -159,90 +159,55 @@ bool loadFITS(QString path, ImageInfoData &info, RawImage **image, QImage *qimag
     {
         int imgtype;
         int naxis;
-        long naxes[2];
-        fits_get_img_param(file, 2, &imgtype, &naxis, naxes, &status);
+        long naxes[3];
+        fits_get_img_param(file, 3, &imgtype, &naxis, naxes, &status);
 
         if(naxis >= 2 && naxis <= 3 && status == 0)
         {
-            std::vector<uint8_t> bits8;
-            std::vector<uint16_t> bits16;
-            std::vector<uint32_t> bits32;
-            std::vector<float> bits32f;
+            int cvtype;
+            int fitstype;
+            std::vector<cv::Mat> cvimg;
             long fpixel[3] = {1,1,1};
+            switch(imgtype)
+            {
+            case BYTE_IMG:
+                cvtype = CV_8U;
+                fitstype = TBYTE;
+                break;
+            case SHORT_IMG:
+                cvtype = CV_16U;
+                fitstype = TUSHORT;
+                break;
+            case FLOAT_IMG:
+                cvtype = CV_32F;
+                fitstype = TFLOAT;
+                break;
+            }
 
             size_t size = naxes[0]*naxes[1];
             size_t w = naxes[0];
             size_t h = naxes[1];
-            if(qimage)
-                *qimage = QImage(naxes[0], naxes[1], QImage::Format_Grayscale8);
 
             info.append(StringPair(QObject::tr("Width"), QString::number(naxes[0])));
             info.append(StringPair(QObject::tr("Height"), QString::number(naxes[1])));
 
-            switch(imgtype)
+            for (int i=1; i==1 || i<=naxes[2]; i++)
             {
-            case BYTE_IMG:
-                bits8.resize(size);
-                fits_read_pix(file, TBYTE, fpixel, size, NULL, &bits8[0], NULL, &status);
-                if(status)break;
-                if(qimage)
-                {
-                    for(size_t i=0; i<h; i++)
-                        memcpy(qimage->scanLine(i), &bits8[i*w], w*sizeof(uint8_t));
+                cv::Mat tmp(h, w, cvtype);
+                fpixel[2] = i;
+                fits_read_pix(file, fitstype, fpixel, size, NULL, tmp.ptr(), NULL, &status);
+                cvimg.push_back(tmp);
             }
-                if(image)
+
+            if(cvimg.size() == 1)
             {
-                    *image = new RawImage(naxes[0], naxes[1], RawImage::UINT8);
-                    memcpy((*image)->data(), &bits8[0], sizeof(uint8_t)*h*w);
+                *image = new RawImage(cvimg[0]);
             }
-                break;
-            case SHORT_IMG:
-                bits16.resize(size);
-                fits_read_pix(file, TUSHORT, fpixel, size, NULL, &bits16[0], NULL, &status);
-                if(status)break;
-                if(qimage)
+            if(cvimg.size() == 3)
             {
-                    for(size_t i=0; i<h; i++)
-                    {
-                        uchar *scanline = qimage->scanLine(i);
-                        for(size_t o=0;o<w;o++)
-                            scanline[o] = bits16[i*w+o] >> 8;
-                    }
-                }
-                if(image)
-                {
-                    *image = new RawImage(naxes[0], naxes[1], RawImage::UINT16);
-                    memcpy((*image)->data(), &bits16[0], sizeof(uint16_t)*h*w);
-                }
-                break;
-            case LONG_IMG:
-                /*bits32.resize(size);
-                fits_read_pix(file, TUINT, fpixel, size, NULL, &bits32[0], NULL, &status);
-                if(status)break;
-                if(qimage)
-                {
-                    for(size_t i=0; i<h; i++)
-                    {
-                        uchar *scanline = qimage->scanLine(i);
-                        for(size_t o=0;o<w;o++)
-                            scanline[o] = bits32[i*w+o] >> 24;
-                    }
-                }
-                if(image)
-                {
-                    *image = new RawImage(naxes[0], naxes[1], RawImage::FLOAT32);
-                    memcpy((*image)->data(), &bits8[0], sizeof(uint32_t)*h*w);
-                }*/
-                break;
-            case FLOAT_IMG:
-                bits32f.resize(size);
-                fits_read_pix(file, TFLOAT, fpixel, size, NULL, &bits32f[0], NULL, &status);
-                if(status)break;
-                if(image)
-                {
-                    *image = new RawImage(naxes[0], naxes[1], RawImage::FLOAT32);
-                    memcpy((*image)->data(), &bits32f[0], sizeof(float)*h*w);
-                }
+                cv::Mat rgb;
+                cv::merge(cvimg, rgb);
+                *image = new RawImage(rgb);
             }
         }
     }
@@ -287,13 +252,13 @@ void LoadRunable::run()
     if(m_file.endsWith(".CR2", Qt::CaseInsensitive))
     {
         timer.start();
-        loadRAW(m_file, info, &rawImage, &img);
+        loadRAW(m_file, info, &rawImage, nullptr);
         raw = true;
         qDebug() << "LoadRaw" << timer.elapsed();
     }
     else if(m_file.endsWith(".FIT", Qt::CaseInsensitive) || m_file.endsWith(".FITS", Qt::CaseInsensitive))
     {
-        loadFITS(m_file, info, &rawImage, &img);
+        loadFITS(m_file, info, &rawImage, nullptr);
     }
     else
     {

rawimage.cpp

@@ -55,6 +55,11 @@ RawImage::RawImage(int w, int h, ImgType type)
     m_img.create(h, w, Type2CV(type));
 }
 
+RawImage::RawImage(cv::Mat &img)
+{
+    m_img = img;
+}
+
 RawImage::RawImage(const RawImage &d)
 {
     d.m_img.copyTo(m_img);
@@ -161,17 +166,7 @@ uint32_t RawImage::size() const
 
 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;
-    }
+    return CV2Type(m_img.type());
 }
 
 void* RawImage::data()

rawimage.h

@@ -47,6 +47,7 @@ public:
     };
     RawImage();
     RawImage(int w, int h, ImgType type);
+    RawImage(cv::Mat &img);
     RawImage(const RawImage &d);
     bool imageStats(double *mean, double *stdDev, double *median, double *min, double *max) const;
     void rect(int &x, int &y, int w, int h, std::vector<double> &r) const;