Get rid of QPixmap

imageringlist.cpp

@@ -19,19 +19,18 @@ Image::Image(const QString name, ImageRingList *ringList) :
 
 void Image::load()
 {
-    if(m_pixmap.isNull() && !m_rawImage && !m_loading)
+    if(!m_rawImage && !m_loading)
     {
         m_loading = true;
         m_released = false;
         QThreadPool::globalInstance()->start(new LoadRunable(m_name, this, m_ringList->analyzeLevel()));
     }
-    if(!m_loading && (!m_pixmap.isNull() || m_rawImage))
+    if(!m_loading && m_rawImage)
         emit pixmapLoaded(this);
 }
 
 void Image::release()
 {
-    m_pixmap = QPixmap();
     m_rawImage.reset();
     m_released = true;
     m_loading = false;
@@ -42,11 +41,6 @@ QString Image::name() const
     return m_name;
 }
 
-QPixmap Image::pixmap() const
-{
-    return m_pixmap;
-}
-
 RawImage *Image::rawImage()
 {
     return m_rawImage.get();
@@ -62,12 +56,11 @@ bool Image::isCurrent() const
     return !m_released;
 }
 
-void Image::imageLoaded(QImage img, void *rawImage, ImageInfoData info)
+void Image::imageLoaded(void *rawImage, ImageInfoData info)
 {
     m_loading = false;
     if(!m_released)
     {
-        m_pixmap = QPixmap::fromImage(img);
         m_rawImage.reset(static_cast<RawImage*>(rawImage));
         m_info = info;
         emit pixmapLoaded(this);

imageringlist.h

@@ -17,7 +17,6 @@ class Image : public QObject
     bool m_loading;
     bool m_released;
     bool m_current;
-    QPixmap m_pixmap;
     std::unique_ptr<RawImage> m_rawImage;
     QString m_name;
     ImageInfoData m_info;
@@ -27,14 +26,13 @@ public:
     void load();
     void release();
     QString name() const;
-    QPixmap pixmap() const;
     RawImage* rawImage();
     ImageInfoData info() const;
     bool isCurrent() const;
 signals:
     void pixmapLoaded(Image *ptr);
 protected slots:
-    void imageLoaded(QImage img, void *rawImage, ImageInfoData info);
+    void imageLoaded(void *rawImage, ImageInfoData info);
 };
 
 typedef std::shared_ptr<Image> ImagePtr;

imagescrollareagl.cpp

@@ -19,7 +19,7 @@ const RawImageType rawImageTypes[] = {
     {QOpenGLTexture::Red, QOpenGLTexture::R8_UNorm, QOpenGLTexture::UInt8, true},
     {QOpenGLTexture::Red, QOpenGLTexture::R16_UNorm, QOpenGLTexture::UInt16, true},
     {QOpenGLTexture::Red, QOpenGLTexture::R32F, QOpenGLTexture::Float32, true},
-    {QOpenGLTexture::RGB, QOpenGLTexture::R8_UNorm, QOpenGLTexture::UInt8, false},
+    {QOpenGLTexture::RGB, QOpenGLTexture::RGB8_UNorm, QOpenGLTexture::UInt8, false},
     {QOpenGLTexture::RGB, QOpenGLTexture::RGB16_UNorm, QOpenGLTexture::UInt16, false},
     {QOpenGLTexture::RGB, QOpenGLTexture::RGB32F, QOpenGLTexture::Float32, false}
 };

loadrunable.cpp

@@ -75,9 +75,9 @@ void printStarModel(int radius, const std::vector<double> &data, const Star &sta
     std::cout << m.toStdString() << std::endl << std::endl;
 }
 
-bool loadRAW(QString path, ImageInfoData &info, RawImage **image, QImage *qimage)
+bool loadRAW(QString path, ImageInfoData &info, RawImage **image)
 {
-    if(!image && !qimage)
+    if(!image)
         return false;
 
     LibRaw raw;
@@ -112,41 +112,24 @@ bool loadRAW(QString path, ImageInfoData &info, RawImage **image, QImage *qimage
         memcpy((*image)->data(), &out[0], sizeof(uint16_t)*d);
     }
 
-    if(qimage)
-    {
-        raw.dcraw_process();
-        libraw_processed_image_t *rawImg = raw.dcraw_make_mem_image();
-        QImage img(rawImg->width, rawImg->height, QImage::Format_RGB888);
-        uint scanLine = rawImg->width*rawImg->colors;
-
-        for(uint i=0; i<rawImg->height; i++)
-        {
-            memcpy(img.scanLine(i), rawImg->data+(i*scanLine), scanLine);
-        }
-
     QString shutterSpeed = QString::number(raw.imgdata.other.shutter);
     if(raw.imgdata.other.shutter < 1)
     {
         shutterSpeed = QString("1/%1s").arg(1.0f/raw.imgdata.other.shutter);
     }
-        info.append(StringPair(QObject::tr("Width"), QString::number(rawImg->width)));
+    //info.append(StringPair(QObject::tr("Width"), QString::number(rawImg->width)));
-        info.append(StringPair(QObject::tr("Height"), QString::number(rawImg->height)));
+    //info.append(StringPair(QObject::tr("Height"), QString::number(rawImg->height)));
     info.append(StringPair(QObject::tr("ISO"), QString::number(raw.imgdata.other.iso_speed)));
     info.append(StringPair(QObject::tr("Shutter speed"), shutterSpeed));
 #if LIBRAW_MINOR_VERSION>=19
     info.append(StringPair(QObject::tr("Camera temperature"), QString::number(raw.imgdata.other.CameraTemperature)));
 #endif
-        raw.dcraw_clear_mem(rawImg);
-
-        *qimage = img;
-    }
-
     return true;
 }
 
-bool loadFITS(QString path, ImageInfoData &info, RawImage **image, QImage *qimage)
+bool loadFITS(QString path, ImageInfoData &info, RawImage **image)
 {
-    if(!image && !qimage)
+    if(!image)
         return false;
 
     fitsfile *file;
@@ -246,23 +229,22 @@ void LoadRunable::run()
     QFileInfo finfo(m_file);
     info.append(StringPair(QObject::tr("Filename"), finfo.fileName()));
 
-    QImage img;
     RawImage *rawImage = nullptr;
     bool raw = false;
     if(m_file.endsWith(".CR2", Qt::CaseInsensitive))
     {
         timer.start();
-        loadRAW(m_file, info, &rawImage, nullptr);
+        loadRAW(m_file, info, &rawImage);
         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, nullptr);
+        loadFITS(m_file, info, &rawImage);
     }
     else
     {
-        img = QImage(m_file);
+        QImage img(m_file);
         ExifData *exif = exif_data_new_from_file(m_file.toLocal8Bit().constData());
         info.append(StringPair(QObject::tr("Width"), QString::number(img.width())));
         info.append(StringPair(QObject::tr("Height"), QString::number(img.height())));
@@ -272,6 +254,7 @@ void LoadRunable::run()
             loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_SHUTTER_SPEED_VALUE);
             exif_data_free(exif);
         }
+        rawImage = new RawImage(img);
     }
 
     if(rawImage && m_analyzeLevel >= Statistics)
@@ -299,8 +282,8 @@ void LoadRunable::run()
             int numPeaks = medianImage->findPeaks(median+stdDev*2, 20, peaks);
             delete medianImage;
             qDebug() << "peaks" << timer.restart();
-            if(m_analyzeLevel == Peaks)
+            //if(m_analyzeLevel == Peaks)
-                drawPeaks(img, peaks);
+            //    drawPeaks(img, peaks);
             qDebug() << "draw peaks" << timer.restart();
             info.append(StringPair(QObject::tr("Peaks"), QString::number(numPeaks)));
             info.append(StringPair(QObject::tr("Peaks draw"), QString::number(peaks.size())));
@@ -330,7 +313,7 @@ void LoadRunable::run()
                         stars.push_back(star);
                     }
                 }
-                drawStars(img, stars);
+                //drawStars(img, stars);
                 info.append(StringPair(QObject::tr("FWHM X"), QString::number(fwhmX/stars.size())));
                 info.append(StringPair(QObject::tr("FWHM Y"), QString::number(fwhmY/stars.size())));
             }
@@ -338,5 +321,5 @@ void LoadRunable::run()
         }
     }
 
-    QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(QImage, img), Q_ARG(void*, rawImage), Q_ARG(ImageInfoData, info));
+    QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(void*, rawImage), Q_ARG(ImageInfoData, info));
 }

mainwindow.cpp

@@ -237,10 +237,6 @@ void MainWindow::pixmapLoaded(Image *image)
     {
         m_imageGL->setImage(image->rawImage());
     }
-    else
-    {
-        m_imageGL->setImage(image->pixmap());
-    }
 }
 
 void MainWindow::loadFile()

rawimage.cpp

@@ -65,6 +65,15 @@ RawImage::RawImage(const RawImage &d)
     d.m_img.copyTo(m_img);
 }
 
+RawImage::RawImage(const QImage &img)
+{
+    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);
+}
+
 bool RawImage::imageStats(double *mean, double *stdDev, double *median, double *min, double *max) const
 {
     cv::Scalar meanS, stdDevS;

rawimage.h

@@ -7,6 +7,7 @@
 #include <math.h>
 #include <memory.h>
 #include <opencv2/imgproc.hpp>
+#include <QImage>
 
 class Peak
 {
@@ -49,6 +50,7 @@ public:
     RawImage(int w, int h, ImgType type);
     RawImage(cv::Mat &img);
     RawImage(const RawImage &d);
+    RawImage(const QImage &img);
     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;
     int findPeaks(double background, double distance, std::vector<Peak> &peaks) const;