Bumb GLSL version to 330

CMakeLists.txt

@@ -15,9 +15,10 @@ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s")
 find_package(Qt5 COMPONENTS Widgets Sql OpenGL REQUIRED)
 find_package(OpenCV REQUIRED)
 find_library(GSL_LIB gsl REQUIRED)
+find_library(GSLCBLAS_LIB gslcblas REQUIRED)
 find_library(EXIF_LIB exif REQUIRED)
 find_library(FITS_LIB cfitsio REQUIRED)
-find_library(RAW_LIB NAMES raw_r raw REQUIRED)
+find_library(RAW_LIB NAMES raw_r REQUIRED)
 
 set(TENMON_SRC
     database.cpp
@@ -33,27 +34,35 @@ set(TENMON_SRC
     rawimage.cpp
     starfit.cpp
     stfslider.cpp
-    stretchpanel.cpp
+    stretchtoolbar.cpp
 )
 
 qt5_add_resources(TENMON_SRC resources.qrc)
 if(WIN32)
     list(APPEND TENMON_SRC icon.rc)
     add_compile_definitions("__PCL_WINDOWS")
-endif(WIN32)
-if(${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Linux")
+else()
     add_compile_definitions("__PCL_LINUX")
 endif()
 
-add_executable(tenmon ${TENMON_SRC})
+add_executable(tenmon WIN32 ${TENMON_SRC})
 
 find_path(FITS_INCLUDE fitsio2.h PATH_SUFFIXES cfitsio REQUIRED)
 target_include_directories(tenmon PRIVATE ${OpenCV_INCLUDE_DIRS} ${FITS_INCLUDE} 3rdparty/include)
 
-target_link_libraries(tenmon Qt5::Widgets Qt5::Sql Qt5::OpenGL ${OpenCV_LIBS} ${GSL_LIB} ${EXIF_LIB} ${FITS_LIB} ${RAW_LIB})
+if(WIN32)
+    target_link_directories(tenmon PRIVATE 3rdparty/lib/Windows)
+else()
+    target_link_directories(tenmon PRIVATE 3rdparty/lib/Linux)
+endif()
 
-target_link_directories(tenmon PRIVATE 3rdparty/lib/${CMAKE_HOST_SYSTEM_NAME})
-target_link_libraries(tenmon PCL lcms  lz4  RFC6234 zlib)
+target_link_libraries(tenmon Qt5::Widgets Qt5::Sql ${OpenCV_LIBS} ${GSL_LIB} ${GSLCBLAS_LIB} ${EXIF_LIB} ${FITS_LIB} ${RAW_LIB})
+target_link_libraries(tenmon PCL lcms lz4  RFC6234 zlib)
+
+if(LIBRAW_STATIC)
+    add_compile_definitions("LIBRAW_NODLL")
+    target_link_libraries(tenmon jasper)
+endif()
 
 install(TARGETS tenmon)
 if(UNIX)

image.frag

@@ -1,10 +1,10 @@
-#version 130
+#version 330
 
 uniform sampler2D qt_Texture0;
-in vec2 qt_TexCoord0;
 uniform vec3 mtf_param;
 uniform bool bw;
 uniform bool invert;
+in vec2 qt_TexCoord0;
 out vec4 color;
 
 vec4 MTF(vec4 x, vec3 m)
@@ -16,7 +16,7 @@ vec4 MTF(vec4 x, vec3 m)
 
 void main(void)
 {
-    color = texture2D(qt_Texture0, qt_TexCoord0);
+    color = texture(qt_Texture0, qt_TexCoord0);
     if(bw)color = color.rrra;
     color = MTF(color, mtf_param);
 

image.vert

@@ -1,4 +1,4 @@
-#version 130
+#version 330
 
 uniform sampler2D qt_Texture0;
 in vec2 qt_Vertex;

imageringlist.cpp

@@ -8,10 +8,11 @@ using namespace std;
 
 const int DEFAULT_WIDTH = 2;
 
-Image::Image(const QString name, ImageRingList *ringList) :
+Image::Image(const QString name, int number, ImageRingList *ringList) :
     m_loading(false),
     m_released(true),
     m_current(false),
+    m_number(number),
     m_name(name),
     m_ringList(ringList)
 {
@@ -29,6 +30,14 @@ void Image::load()
         emit pixmapLoaded(this);
 }
 
+void Image::loadThumbnail(QThreadPool *pool)
+{
+    if(!m_thumbnail)
+        pool->start(new LoadRunable(m_name, this, AnalyzeLevel::None, true));
+    else
+        emit thumbnailLoaded(this);
+}
+
 void Image::release()
 {
     m_rawImage.reset();
@@ -46,6 +55,11 @@ RawImage *Image::rawImage()
     return m_rawImage.get();
 }
 
+const RawImage *Image::thumbnail() const
+{
+    return m_thumbnail.get();
+}
+
 ImageInfoData Image::info() const
 {
     return m_info;
@@ -56,6 +70,11 @@ bool Image::isCurrent() const
     return !m_released;
 }
 
+int Image::number() const
+{
+    return m_number;
+}
+
 void Image::imageLoaded(void *rawImage, ImageInfoData info)
 {
     m_loading = false;
@@ -71,17 +90,28 @@ void Image::imageLoaded(void *rawImage, ImageInfoData info)
     }
 }
 
+void Image::thumbnailLoadFinish(void *rawImage)
+{
+    m_thumbnail.reset(static_cast<RawImage*>(rawImage));
+    if(m_thumbnail)
+        emit thumbnailLoaded(this);
+}
+
 ImageRingList::ImageRingList(QObject *parent) : QAbstractItemModel(parent)
   , m_liveMode(false)
   , m_analyzeLevel(None)
 {
     connect(&m_fileSystemWatcher, SIGNAL(directoryChanged(QString)), this, SLOT(dirChanged(QString)));
+    m_thumbPool = new QThreadPool(this);
 }
 
 ImageRingList::~ImageRingList()
 {
     QThreadPool::globalInstance()->clear();
+    m_thumbPool->clear();
+
     QThreadPool::globalInstance()->waitForDone();
+    m_thumbPool->waitForDone();
 }
 
 bool ImageRingList::setDir(const QString path, const QString &currentFile)
@@ -93,7 +123,7 @@ bool ImageRingList::setDir(const QString path, const QString &currentFile)
         QStringList nameFilter;
         nameFilter << "*.jpg" << "*.jpeg" << "*.png" << "*.cr2" << "*.fit" << "*.fits" << "*.xisf";
 
-        QStringList list = dir.entryList(nameFilter, QDir::Files | QDir::Readable, m_liveMode ? QDir::Time : QDir::Name);
+        QStringList list = dir.entryList(nameFilter, QDir::Files | QDir::Readable, m_liveMode ? QDir::Time : QDir::Name | QDir::IgnoreCase);
         QStringList absolutePaths;
         foreach(const QString &file, list)
         {
@@ -209,6 +239,24 @@ void ImageRingList::loadFile(int row)
     }
 }
 
+void ImageRingList::loadThumbnails()
+{
+    for(auto &img : m_images)
+    {
+        img->loadThumbnail(m_thumbPool);
+    }
+}
+
+void ImageRingList::stopLoading()
+{
+    m_thumbPool->clear();
+}
+
+int ImageRingList::imageCount() const
+{
+    return m_images.size();
+}
+
 QModelIndex ImageRingList::index(int row, int column, const QModelIndex &parent) const
 {
     return createIndex(row, column, m_images.at(row).get());
@@ -261,10 +309,12 @@ void ImageRingList::setFiles(const QStringList files, const QString &currentFile
     QThreadPool::globalInstance()->waitForDone();
     beginResetModel();
     m_images.clear();
-    foreach(const QString &file, files)
+    int i = 0;
+    for(const QString &file : files)
     {
-        ImagePtr ptr = make_shared<Image>(file, this);
+        ImagePtr ptr = make_shared<Image>(file, i++, this);
         connect(ptr.get(), SIGNAL(pixmapLoaded(Image*)), this, SLOT(imageLoaded(Image*)));
+        connect(ptr.get(), SIGNAL(thumbnailLoaded(Image*)), this, SIGNAL(thumbnailLoaded(Image*)));
         m_images.append(ptr);
     }
 

imageringlist.h

@@ -10,6 +10,7 @@
 #include "rawimage.h"
 
 class ImageRingList;
+class QThreadPool;
 
 class Image : public QObject
 {
@@ -17,22 +18,29 @@ class Image : public QObject
     bool m_loading;
     bool m_released;
     bool m_current;
+    int m_number;
     std::unique_ptr<RawImage> m_rawImage;
+    std::unique_ptr<RawImage> m_thumbnail;
     QString m_name;
     ImageInfoData m_info;
     ImageRingList *m_ringList;
 public:
-    explicit Image(const QString name, ImageRingList *ringList);
+    explicit Image(const QString name, int number, ImageRingList *ringList);
     void load();
+    void loadThumbnail(QThreadPool *pool);
     void release();
     QString name() const;
     RawImage* rawImage();
+    const RawImage* thumbnail() const;
     ImageInfoData info() const;
     bool isCurrent() const;
+    int number() const;
 signals:
     void pixmapLoaded(Image *ptr);
+    void thumbnailLoaded(Image *ptr);
 protected slots:
     void imageLoaded(void *rawImage, ImageInfoData info);
+    void thumbnailLoadFinish(void *rawImage);
 };
 
 typedef std::shared_ptr<Image> ImagePtr;
@@ -48,6 +56,7 @@ class ImageRingList : public QAbstractItemModel
     QFileSystemWatcher m_fileSystemWatcher;
     bool m_liveMode;
     AnalyzeLevel m_analyzeLevel;
+    QThreadPool *m_thumbPool;
 public:
     explicit ImageRingList(QObject *parent = 0);
     ~ImageRingList();
@@ -62,6 +71,9 @@ public:
     void setFindStars(bool findStars);
     AnalyzeLevel analyzeLevel() const;
     void loadFile(int row);
+    void loadThumbnails();
+    void stopLoading();
+    int imageCount() const;
 
     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex &child) const override;
@@ -75,6 +87,7 @@ protected:
     QList<ImagePtr>::iterator decrement(QList<ImagePtr>::iterator iter);
 signals:
     void pixmapLoaded(Image *image);
+    void thumbnailLoaded(Image *image);
     void infoLoaded(ImageInfoData info);
     void currentImageChanged(int index);
 protected slots:

imagescrollareagl.cpp

@@ -6,6 +6,7 @@
 #include <QOpenGLPixelTransferOptions>
 #include <QOpenGLFramebufferObject>
 #include <QGridLayout>
+#include <QMimeData>
 
 struct RawImageType
 {
@@ -54,6 +55,13 @@ ImageWidget::ImageWidget(QWidget *parent) : QOpenGLWidget(parent)
     m_range = UINT16_MAX;
     m_imgWidth = m_imgHeight = -1;
     m_superpixel = m_invert = false;
+    m_showThumbnails = false;
+    m_thumbnailCount = 0;
+    m_updateTimer = new QTimer(this);
+    m_updateTimer->setInterval(500);
+    m_updateTimer->setSingleShot(true);
+    connect(m_updateTimer, SIGNAL(timeout()), this, SLOT(update()));
+    setAcceptDrops(true);
 }
 
 ImageWidget::~ImageWidget()
@@ -113,6 +121,22 @@ void ImageWidget::blockRepaint(bool block)
     if(!block)update();
 }
 
+void ImageWidget::allocateThumbnails(int count)
+{
+    m_thumbnailTexture->destroy();
+    m_thumbnailTexture->create();
+    m_thumbnailTexture->setFormat(QOpenGLTexture::RGB16_UNorm);
+    m_thumbnailTexture->setSize(THUMB_SIZE, THUMB_SIZE);
+    m_thumbnailTexture->setLayers(count);
+    m_thumbnailTexture->allocateStorage();
+    m_bufferSizes->bind();
+    float *tmp = new float[count*3];
+    memset(tmp, 0, count * sizeof(float)*3);
+    m_bufferSizes->allocate(tmp, count * sizeof(float)*3);
+    delete [] tmp;
+    m_thumbnailCount = count;
+}
+
 void ImageWidget::setMTFParams(float low, float mid, float high)
 {
     m_low = low;
@@ -162,6 +186,23 @@ QImage ImageWidget::renderToImage()
     return fbo.toImage(true);
 }
 
+void ImageWidget::thumbnailLoaded(const Image *image)
+{
+    const RawImage *raw = image->thumbnail();
+    m_thumbnailTexture->setData(0, image->number(), QOpenGLTexture::RGB, QOpenGLTexture::UInt16, raw->data(), m_transferOptions.get());
+    float a = raw->thumbAspect();
+    int sizes[3] = { std::max(1, a > 1.0f ? THUMB_SIZE : (int)(THUMB_SIZE * a)), std::max(1, a < 1.0f ? THUMB_SIZE : (int)(THUMB_SIZE / a)), image->number() };
+    m_bufferSizes->bind();
+    m_bufferSizes->write(image->number() * sizeof(sizes), sizes, sizeof(sizes));
+    if(!m_updateTimer->isActive())m_updateTimer->start();
+}
+
+void ImageWidget::showThumbnail(bool enable)
+{
+    m_showThumbnails = enable;
+    update();
+}
+
 void ImageWidget::paintGL()
 {
     if(m_blockRepaint)return;
@@ -173,16 +214,35 @@ void ImageWidget::paintGL()
     if(height() > m_image->height()*m_scale)
         dy = -height()*0.5f + m_image->height()*m_scale*0.5f;
 
-    m_program->bind();
-    m_program->setUniformValue("viewport", (float)width(), (float)height());
-    m_program->setUniformValue("offset", dx, dy);
-    m_program->setUniformValue("mtf_param", m_low, m_mid, m_high);
-    m_program->setUniformValue("zoom", 1.0f/m_scale);
-    m_program->setUniformValue("bw", m_bwImg);
-    m_program->setUniformValue("invert", m_invert);
+    if(m_showThumbnails)
+    {
+        m_vaoThumb->bind();
+        m_thumbnailTexture->bind(1);
+        m_thumbnailProgram->bind();
+        f->glUniform3i(m_thumbnailProgram->uniformLocation("viewport_row"), width(), height(), width()/THUMB_SIZE_BORDER);
+        m_thumbnailProgram->setUniformValue("mtf_param", m_low, m_mid, m_high);
+        m_thumbnailProgram->setUniformValue("invert", m_invert);
+        m_thumbnailProgram->setUniformValue("offset", 0, m_dy);
+        f3->glVertexAttribDivisor(m_thumbnailProgram->attributeLocation("imageSize_num"), 1);
+        QMatrix4x4 mvp;
+        mvp.ortho(rect());
+        m_thumbnailProgram->setUniformValue("mvp", mvp);
+        if(f3)f3->glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, m_thumbnailCount);
+    }
+    else
+    {
+        m_vao->bind();
+        m_image->bind(0);
+        m_program->bind();
+        m_program->setUniformValue("viewport", (float)width(), (float)height());
+        m_program->setUniformValue("offset", dx, dy);
+        m_program->setUniformValue("mtf_param", m_low, m_mid, m_high);
+        m_program->setUniformValue("zoom", 1.0f/m_scale);
+        m_program->setUniformValue("bw", m_bwImg);
+        m_program->setUniformValue("invert", m_invert);
+        f->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    }
 
-    m_image->bind(0);
-    f->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 }
 
 void ImageWidget::resizeGL(int w, int h)
@@ -196,10 +256,12 @@ void ImageWidget::initializeGL()
 {
     f = context()->functions();
     f->glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
-    QOpenGLFunctions_3_2_Core *f3 = context()->versionFunctions<QOpenGLFunctions_3_2_Core>();
+    f3 = context()->versionFunctions<QOpenGLFunctions_3_3_Core>();
 
     m_vao = std::unique_ptr<QOpenGLVertexArrayObject>(new QOpenGLVertexArrayObject);
+    m_vaoThumb = std::unique_ptr<QOpenGLVertexArrayObject>(new QOpenGLVertexArrayObject);
     m_vao->create();
+    m_vaoThumb->create();
     m_vao->bind();
 
     QOpenGLDebugLogger *logger = new QOpenGLDebugLogger(this);
@@ -226,7 +288,7 @@ void ImageWidget::initializeGL()
     m_buffer->create();
     m_buffer->bind();
     m_buffer->allocate(vertexs, sizeof(vertexs));
-    f->glVertexAttribPointer(0, 2, GL_FLOAT, false, sizeof(float)*4, 0);
+    // f->glVertexAttribPointer(0, 2, GL_FLOAT, false, sizeof(float)*4, 0);
 
     m_program = std::unique_ptr<QOpenGLShaderProgram>(new QOpenGLShaderProgram);
     m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shaders/image.vert");
@@ -245,6 +307,33 @@ void ImageWidget::initializeGL()
     m_program->setUniformValue("qt_Texture0", (GLuint)0);
     m_program->setUniformValue("scale", 1.0f, 0.0f);
 
+    m_vaoThumb->bind();
+
+    m_thumbnailProgram = std::unique_ptr<QOpenGLShaderProgram>(new QOpenGLShaderProgram);
+    m_thumbnailProgram->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shaders/thumb.vert");
+    m_thumbnailProgram->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shaders/thumb.frag");
+    if(f3)f3->glBindFragDataLocation(m_program->programId(), 0, "color");
+    m_thumbnailProgram->bind();
+    m_thumbnailProgram->enableAttributeArray("qt_Vertex");
+    m_thumbnailProgram->setAttributeBuffer("qt_Vertex", GL_FLOAT, 0, 2, sizeof(float)*4);
+    m_thumbnailProgram->enableAttributeArray("qt_MultiTexCoord0");
+    m_thumbnailProgram->setAttributeBuffer("qt_MultiTexCoord0", GL_FLOAT, sizeof(float)*2, 2, sizeof(float)*4);
+    if(!m_thumbnailProgram->link())
+    {
+        qDebug() << "Link failed" << m_thumbnailProgram->log();
+    }
+    m_thumbnailProgram->setUniformValue("qt_Texture0", (GLuint)1);
+
+    m_bufferSizes = std::unique_ptr<QOpenGLBuffer>(new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer));
+    m_bufferSizes->setUsagePattern(QOpenGLBuffer::StaticDraw);
+    m_bufferSizes->create();
+    m_bufferSizes->bind();
+
+    m_bufferSizes->allocate(12);
+    m_thumbnailProgram->enableAttributeArray("imageSize_num");
+    m_thumbnailProgram->setAttributeBuffer("imageSize_num", GL_FLOAT, 0, 3);
+    f3->glVertexAttribDivisor(m_thumbnailProgram->attributeLocation("imageSize_num"), 1);
+
     m_image = std::unique_ptr<QOpenGLTexture>(new QOpenGLTexture(QOpenGLTexture::Target2D));
     m_image->setFormat(QOpenGLTexture::RGB8U);
     m_image->allocateStorage();
@@ -252,10 +341,42 @@ void ImageWidget::initializeGL()
     m_image->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
     m_image->setMagnificationFilter(QOpenGLTexture::Linear);
 
+    m_thumbnailTexture = std::unique_ptr<QOpenGLTexture>(new QOpenGLTexture(QOpenGLTexture::Target2DArray));
+    m_thumbnailTexture->setFormat(QOpenGLTexture::RGB16_UNorm);
+    m_thumbnailTexture->setSize(THUMB_SIZE, THUMB_SIZE);
+    m_thumbnailTexture->setLayers(1);
+    m_thumbnailTexture->allocateStorage();
+    m_thumbnailTexture->bind(1);
+    m_thumbnailTexture->setMinificationFilter(QOpenGLTexture::Linear);
+    m_thumbnailTexture->setMinificationFilter(QOpenGLTexture::Linear);
+
     m_transferOptions = std::unique_ptr<QOpenGLPixelTransferOptions>(new QOpenGLPixelTransferOptions);
     m_transferOptions->setAlignment(1);
 }
 
+void ImageWidget::dragEnterEvent(QDragEnterEvent *event)
+{
+    if(event->mimeData()->hasUrls() && event->proposedAction() & (Qt::CopyAction | Qt::MoveAction))
+        event->acceptProposedAction();
+}
+
+void ImageWidget::dropEvent(QDropEvent *event)
+{
+    if(event->mimeData()->hasUrls() && event->proposedAction() & (Qt::CopyAction | Qt::MoveAction))
+    {
+        for(const QUrl &url : event->mimeData()->urls())
+        {
+            if(url.isLocalFile())
+            {
+                emit fileDropped(url.path());
+                event->accept();
+                return;
+            }
+        }
+    }
+    event->ignore();
+}
+
 ImageScrollAreaGL::ImageScrollAreaGL(QWidget *parent) : QWidget(parent)
 {
     QGridLayout *layout = new QGridLayout(this);
@@ -267,6 +388,7 @@ ImageScrollAreaGL::ImageScrollAreaGL(QWidget *parent) : QWidget(parent)
     m_horizontalScrollBar = new QScrollBar(Qt::Horizontal, this);
     m_scale = 1.0f;
     m_bestFit = false;
+    m_thumbCount = 0;
 
     layout->setSpacing(0);
     layout->addWidget(m_imageWidget, 0, 0);
@@ -305,32 +427,66 @@ ImageWidget *ImageScrollAreaGL::imageWidget()
     return m_imageWidget;
 }
 
-void ImageScrollAreaGL::updateScrollbars(bool zoom)
+void ImageScrollAreaGL::setThumbnails(int count)
 {
-    if(zoom)
+    m_thumbCount = count;
+    if(m_thumbCount)
     {
-        setScrollRange(m_verticalScrollBar, m_imgHeight*m_scale);
-        setScrollRange(m_horizontalScrollBar, m_imgWidth*m_scale);
+        m_verticalScrollBar->setRange(0, m_thumbCount / (m_imageWidget->width() / THUMB_SIZE_BORDER) * THUMB_SIZE_BORDER);
+        m_verticalScrollBar->setPageStep(THUMB_SIZE_BORDER);
     }
     else
     {
-        m_verticalScrollBar->setRange(0, m_imgHeight*m_scale - m_verticalScrollBar->pageStep());
-        m_horizontalScrollBar->setRange(0, m_imgWidth*m_scale - m_horizontalScrollBar->pageStep());
+        m_verticalScrollBar->setPageStep(m_imageWidget->height());
+        m_horizontalScrollBar->setPageStep(m_imageWidget->width());
+    }
+    updateScrollbars();
+}
+
+void ImageScrollAreaGL::updateScrollbars(bool zoom)
+{
+    if(m_thumbCount)
+    {
+        m_horizontalScrollBar->hide();
+        m_verticalScrollBar->show();
+        m_verticalScrollBar->setRange(0, m_thumbCount / (m_imageWidget->width() / THUMB_SIZE_BORDER) * THUMB_SIZE_BORDER);
+        m_verticalScrollBar->setPageStep(THUMB_SIZE_BORDER);
+    }
+    else
+    {
+        if(zoom)
+        {
+            setScrollRange(m_verticalScrollBar, m_imgHeight*m_scale);
+            setScrollRange(m_horizontalScrollBar, m_imgWidth*m_scale);
+        }
+        else
+        {
+            m_verticalScrollBar->setRange(0, m_imgHeight*m_scale - m_verticalScrollBar->pageStep());
+            m_horizontalScrollBar->setRange(0, m_imgWidth*m_scale - m_horizontalScrollBar->pageStep());
+        }
     }
 }
 
 void ImageScrollAreaGL::resizeEvent(QResizeEvent *event)
 {
     QWidget::resizeEvent(event);
-    m_verticalScrollBar->setPageStep(m_imageWidget->height());
-    m_horizontalScrollBar->setPageStep(m_imageWidget->width());
+    if(m_thumbCount)
+    {
+        m_verticalScrollBar->setRange(0, m_thumbCount / (m_imageWidget->width() / THUMB_SIZE_BORDER) * THUMB_SIZE_BORDER);
+        m_verticalScrollBar->setPageStep(THUMB_SIZE_BORDER);
+    }
+    else
+    {
+        m_verticalScrollBar->setPageStep(m_imageWidget->height());
+        m_horizontalScrollBar->setPageStep(m_imageWidget->width());
+    }
     updateScrollbars();
 }
 
 void ImageScrollAreaGL::mouseMoveEvent(QMouseEvent *event)
 {
     QPoint delta = m_lastPos - event->pos();
-    m_horizontalScrollBar->setValue(m_horizontalScrollBar->value() + delta.x());
+    if(m_thumbCount == 0)m_horizontalScrollBar->setValue(m_horizontalScrollBar->value() + delta.x());
     m_verticalScrollBar->setValue(m_verticalScrollBar->value() + delta.y());
     m_lastPos = event->pos();
 }
@@ -342,9 +498,16 @@ void ImageScrollAreaGL::mousePressEvent(QMouseEvent *event)
 
 void ImageScrollAreaGL::wheelEvent(QWheelEvent *event)
 {
-    m_bestFit = false;
-    if(event->angleDelta().y() != 0)
-        zoom(event->angleDelta().y() / 1200.0f);
+    if(m_thumbCount)
+    {
+        m_verticalScrollBar->setValue(m_verticalScrollBar->value() - event->angleDelta().y());
+    }
+    else
+    {
+        m_bestFit = false;
+        if(event->angleDelta().y() != 0)
+            zoom(event->angleDelta().y() / 1200.0f);
+    }
 }
 
 void ImageScrollAreaGL::zoom(float delta)

imagescrollareagl.h

@@ -4,13 +4,15 @@
 #include <memory>
 #include <QObject>
 #include <QOpenGLWidget>
-#include <QOpenGLFunctions_3_2_Core>
+#include <QOpenGLFunctions_3_3_Core>
 #include <QOpenGLShaderProgram>
 #include <QOpenGLBuffer>
 #include <QOpenGLTexture>
 #include <QOpenGLVertexArrayObject>
 #include <QScrollBar>
+#include <QTimer>
 #include "rawimage.h"
+#include "imageringlist.h"
 
 typedef enum
 {
@@ -25,11 +27,17 @@ class ImageWidget : public QOpenGLWidget
 {
     Q_OBJECT
     QOpenGLFunctions *f;
+    QOpenGLFunctions_3_3_Core *f3;
+    QTimer *m_updateTimer;
     std::unique_ptr<QOpenGLShaderProgram> m_program;
+    std::unique_ptr<QOpenGLShaderProgram> m_thumbnailProgram;
     std::unique_ptr<QOpenGLBuffer> m_buffer;
+    std::unique_ptr<QOpenGLBuffer> m_bufferSizes;
     std::unique_ptr<QOpenGLTexture> m_image;
     std::unique_ptr<QOpenGLVertexArrayObject> m_vao;
+    std::unique_ptr<QOpenGLVertexArrayObject> m_vaoThumb;
     std::unique_ptr<QOpenGLPixelTransferOptions> m_transferOptions;
+    std::unique_ptr<QOpenGLTexture> m_thumbnailTexture;
     int m_width, m_height;
     int m_imgWidth, m_imgHeight;
     float m_low;
@@ -42,6 +50,8 @@ class ImageWidget : public QOpenGLWidget
     bool m_bwImg;
     bool m_invert;
     bool m_superpixel;
+    bool m_showThumbnails;
+    int m_thumbnailCount;
 public:
     explicit ImageWidget(QWidget *parent = nullptr);
     ~ImageWidget();
@@ -49,16 +59,23 @@ public:
     void setImage(const QPixmap &pixmap);
     void setScale(float scale);
     void blockRepaint(bool block);
+    void allocateThumbnails(int count);
 public slots:
     void setMTFParams(float low, float mid, float high);
     void setOffset(int dx, int dy);
     void superPixel(bool enable);
     void invert(bool enable);
     QImage renderToImage();
+    void thumbnailLoaded(const Image *image);
+    void showThumbnail(bool enable);
 protected:
     void paintGL();
     void resizeGL(int w, int h);
     void initializeGL();
+    void dragEnterEvent(QDragEnterEvent *event);
+    void dropEvent(QDropEvent *event);
+signals:
+    void fileDropped(const QString &path);
 };
 
 class ImageScrollAreaGL : public QWidget
@@ -71,12 +88,14 @@ class ImageScrollAreaGL : public QWidget
     QPoint m_lastPos;
     float m_scale;
     bool m_bestFit;
+    int m_thumbCount;
 public:
     explicit ImageScrollAreaGL(QWidget *parent = nullptr);
     ~ImageScrollAreaGL();
     void setImage(RawImage *image);
     void setImage(const QPixmap &pixmap);
     ImageWidget* imageWidget();
+    void setThumbnails(int count);
 protected:
     void updateScrollbars(bool zoom = false);
     void resizeEvent(QResizeEvent *event);

loadrunable.cpp

@@ -13,10 +13,11 @@
 #include "rawimage.h"
 #include "starfit.h"
 
-LoadRunable::LoadRunable(const QString &file, Image *receiver, AnalyzeLevel level) :
+LoadRunable::LoadRunable(const QString &file, Image *receiver, AnalyzeLevel level, bool thumbnail) :
     m_file(file),
     m_receiver(receiver),
-    m_analyzeLevel(level)
+    m_analyzeLevel(level),
+    m_thumbnail(thumbnail)
 {
 }
 
@@ -334,7 +335,7 @@ bool loadXISF(const QString &path, ImageInfoData &info, RawImage **image)
 
 void LoadRunable::run()
 {
-    if(!m_receiver->isCurrent())
+    if(!m_thumbnail && !m_receiver->isCurrent())
     {
         return;
     }
@@ -375,7 +376,7 @@ void LoadRunable::run()
         rawImage = new RawImage(img);
     }
 
-    if(rawImage && m_analyzeLevel >= Statistics)
+    if(rawImage && m_analyzeLevel >= Statistics && !m_thumbnail)
     {
         double mean, median, min, max, mad;
         double stdDev;
@@ -440,7 +441,20 @@ void LoadRunable::run()
         }
     }
 
-    QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(void*, rawImage), Q_ARG(ImageInfoData, info));
+    if(m_thumbnail)
+    {
+        if(rawImage)
+        {
+            rawImage->convertToThumbnail();
+            QMetaObject::invokeMethod(m_receiver, "thumbnailLoadFinish", Qt::QueuedConnection, Q_ARG(void*, rawImage));
+        }
+        else
+        {
+            qDebug() << "failed";
+        }
+    }
+    else
+        QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(void*, rawImage), Q_ARG(ImageInfoData, info));
 }
 
 bool readFITSHeader(const QString &path, ImageInfoData &info)

loadrunable.h

@@ -15,8 +15,9 @@ class LoadRunable : public QRunnable
     QString m_file;
     Image *m_receiver;
     AnalyzeLevel m_analyzeLevel;
+    bool m_thumbnail;
 public:
-    LoadRunable(const QString &file, Image *receiver, AnalyzeLevel level);
+    LoadRunable(const QString &file, Image *receiver, AnalyzeLevel level, bool thumbnail = false);
     void run();
 };
 

main.cpp

@@ -6,7 +6,7 @@ int main(int argc, char *argv[])
 {
     QSurfaceFormat format;
     format.setMajorVersion(3);
-    format.setMinorVersion(2);
+    format.setMinorVersion(3);
     format.setOption(QSurfaceFormat::DebugContext);
     format.setProfile(QSurfaceFormat::OpenGLContextProfile::CoreProfile);
     QSurfaceFormat::setDefaultFormat(format);

mainwindow.cpp

@@ -41,11 +41,11 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
     m_imageGL = new ImageScrollAreaGL(this);
     setCentralWidget(m_imageGL);
 
-    m_stretchPanel = new StretchPanel(this);
+    m_stretchPanel = new StretchToolbar(this);
     connect(m_stretchPanel, SIGNAL(paramChanged(float,float,float)), m_imageGL->imageWidget(), SLOT(setMTFParams(float,float,float)));
-    connect(m_stretchPanel, &StretchPanel::autoStretch, [&](){ m_stretchPanel->stretchImage(m_ringList->currentImage().get()); });
-    connect(m_stretchPanel, &StretchPanel::invert, m_imageGL->imageWidget(), &ImageWidget::invert);
-    connect(m_stretchPanel, &StretchPanel::superPixel, m_imageGL->imageWidget(), &ImageWidget::superPixel);
+    connect(m_stretchPanel, &StretchToolbar::autoStretch, [&](){ m_stretchPanel->stretchImage(m_ringList->currentImage().get()); });
+    connect(m_stretchPanel, &StretchToolbar::invert, m_imageGL->imageWidget(), &ImageWidget::invert);
+    connect(m_stretchPanel, &StretchToolbar::superPixel, m_imageGL->imageWidget(), &ImageWidget::superPixel);
 
     m_ringList = new ImageRingList(this);
     m_filesystem = new FilesystemWidget(m_ringList, this);
@@ -58,10 +58,7 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
     m_databaseView = new DataBaseView(m_database, this);
     connect(m_databaseView, SIGNAL(loadFile(QString)), this, SLOT(loadFile(QString)));
 
-    QDockWidget *stretchDock = new QDockWidget(tr("Stretch"), this);
-    stretchDock->setWidget(m_stretchPanel);
-    stretchDock->setObjectName("strechDock");
-    addDockWidget(Qt::TopDockWidgetArea, stretchDock);
+    addToolBar(Qt::TopToolBarArea, m_stretchPanel);
 
     QDockWidget *filesystemDock = new QDockWidget(tr("Filesystem"), this);
     filesystemDock->setWidget(m_filesystem);
@@ -80,6 +77,8 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
     connect(m_ringList, SIGNAL(currentImageChanged(int)), this, SLOT(updateWindowTitle()));
     connect(m_ringList, SIGNAL(infoLoaded(ImageInfoData)), m_info, SLOT(setInfo(const ImageInfoData&)));
     connect(m_ringList, SIGNAL(currentImageChanged(int)), m_filesystem, SLOT(selectFile(int)));
+    connect(m_ringList, &ImageRingList::thumbnailLoaded, m_imageGL->imageWidget(), &ImageWidget::thumbnailLoaded);
+    connect(m_imageGL->imageWidget(), &ImageWidget::fileDropped, this, static_cast<void (MainWindow::*)(const QString &)>(&MainWindow::loadFile));
 
     QMenu *fileMenu = new QMenu(tr("File"), this);
     fileMenu->addAction(tr("Open"), this, SLOT(loadFile()), QKeySequence("Ctrl+O"));
@@ -96,7 +95,15 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
     viewMenu->addAction(tr("Zoom Out"), m_imageGL, SLOT(zoomOut()), QKeySequence::ZoomOut);
     viewMenu->addAction(tr("Best Fit"), m_imageGL, SLOT(bestFit()), QKeySequence("Ctrl+1"));
     viewMenu->addAction(tr("100%"), m_imageGL, SLOT(oneToOne()));
-    viewMenu->addAction(tr("Fullscreen"), this, SLOT(toggleFullScreen()), QKeySequence::FullScreen);
+    viewMenu->addAction(tr("Fullscreen"), this, SLOT(toggleFullScreen()), Qt::CTRL + Qt::Key_F11);
+    QAction *thumbnailsAction = viewMenu->addAction(tr("Thumbnails"), [this](bool checked){
+        m_imageGL->imageWidget()->allocateThumbnails(m_ringList->imageCount());
+        m_imageGL->imageWidget()->showThumbnail(checked);
+        m_imageGL->setThumbnails(checked ? m_ringList->imageCount() : 0);
+        if(checked)m_ringList->loadThumbnails();
+        else m_ringList->stopLoading();
+    }, Qt::Key_F2);
+    thumbnailsAction->setCheckable(true);
     menuBar()->addMenu(viewMenu);
 
     QMenu *selectMenu = new QMenu(tr("Select"), this);
@@ -134,7 +141,7 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
 
     QMenu *dockMenu = new QMenu(tr("Docks"), this);
     dockMenu->addAction(infoDock->toggleViewAction());
-    dockMenu->addAction(stretchDock->toggleViewAction());
+    dockMenu->addAction(m_stretchPanel->toggleViewAction());
     dockMenu->addAction(filesystemDock->toggleViewAction());
     dockMenu->addAction(databaseViewDock->toggleViewAction());
     menuBar()->addMenu(dockMenu);
@@ -256,7 +263,7 @@ void MainWindow::loadFile()
     loadFile(file);
 }
 
-void MainWindow::loadFile(const QString path)
+void MainWindow::loadFile(const QString &path)
 {
     if(!path.isEmpty())
     {

mainwindow.h

@@ -9,7 +9,7 @@
 #include "imageinfo.h"
 #include "imagescrollareagl.h"
 #include "filesystemwidget.h"
-#include "stretchpanel.h"
+#include "stretchtoolbar.h"
 #include "databaseview.h"
 
 class MainWindow : public QMainWindow
@@ -18,7 +18,7 @@ class MainWindow : public QMainWindow
     ImageScrollArea *m_image;
     ImageScrollAreaGL *m_imageGL;
     ImageRingList *m_ringList;
-    StretchPanel *m_stretchPanel;
+    StretchToolbar *m_stretchPanel;
     Database *m_database;
     ImageInfo *m_info;
     FilesystemWidget *m_filesystem;
@@ -41,7 +41,7 @@ protected slots:
     void updateWindowTitle();
     void pixmapLoaded(Image *image);
     void loadFile();
-    void loadFile(const QString path);
+    void loadFile(const QString &path);
     void loadFile(int row);
     void indexDir();
     void saveAs();

rawimage.cpp

@@ -1,5 +1,4 @@
 #include "rawimage.h"
-#include <QDebug>
 
 RawImage::ImgType CV2Type(int cvtype)
 {
@@ -259,3 +258,33 @@ const void *RawImage::data() const
 {
     return m_img.ptr();
 }
+
+void RawImage::convertToThumbnail()
+{
+    m_thumbAspect = (float)width() / height();
+    switch(CV_MAT_DEPTH(m_img.type()))
+    {
+    case CV_8U:
+        m_img.convertTo(m_img, CV_16U, 255);
+        break;
+    case CV_32F:
+        m_img.convertTo(m_img, CV_16U, 65535);
+        break;
+    case CV_16U:
+        break;
+    default:
+        break;
+    }
+
+    if(m_img.channels() == 1)
+        cv::cvtColor(m_img, m_img, cv::COLOR_GRAY2RGB);
+    if(m_img.channels() == 4)
+        cv::cvtColor(m_img, m_img, cv::COLOR_BGRA2RGB);
+    cv::Size dsize(THUMB_SIZE, THUMB_SIZE);
+    cv::resize(m_img, m_img, dsize, 0, 0, cv::INTER_NEAREST);
+}
+
+float RawImage::thumbAspect() const
+{
+    return m_thumbAspect;
+}

rawimage.h

@@ -9,6 +9,9 @@
 #include <opencv2/imgproc.hpp>
 #include <QImage>
 
+const int THUMB_SIZE = 128;
+const int THUMB_SIZE_BORDER = 138;
+
 class Peak
 {
     uint32_t m_v;
@@ -42,6 +45,7 @@ protected:
     double m_min;
     double m_max;
     double m_mad;
+    float m_thumbAspect;
 public:
     enum ImgType
     {
@@ -72,6 +76,8 @@ public:
     uint32_t norm() const;
     void* data();
     const void* data() const;
+    void convertToThumbnail();
+    float thumbAspect() const;
 };
 
 #endif // RAWIMAGE_H

resources.qrc

@@ -2,6 +2,8 @@
     <qresource prefix="/shaders">
         <file>image.frag</file>
         <file>image.vert</file>
+        <file>thumb.frag</file>
+        <file>thumb.vert</file>
     </qresource>
     <qresource prefix="/">
         <file>icon.png</file>

stfslider.cpp

@@ -12,6 +12,8 @@ static float clamp(float x)
 
 STFSlider::STFSlider(QWidget *parent) : QWidget(parent)
 {
+    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    setMinimumWidth(100);
     setMinimumHeight(15);
     setMaximumHeight(15);
     setMouseTracking(true);

stretchtoolbar.cpp

@@ -1,4 +1,4 @@
-#include "stretchpanel.h"
+#include "stretchtoolbar.h"
 #include <QVBoxLayout>
 #include <QDebug>
 #include <QToolButton>
@@ -15,45 +15,31 @@ float MTF(float x, float m)
     return ((m - 1) * x) / ((2 * m - 1) * x - m);
 }
 
-StretchPanel::StretchPanel(QWidget *parent) : QWidget(parent)
+StretchToolbar::StretchToolbar(QWidget *parent) : QToolBar(tr("Stretch toolbar"), parent)
 {
-    QHBoxLayout *layout = new QHBoxLayout(this);
-    setLayout(layout);
-
+    setObjectName("stretchtoolbar");
     m_stfSlider = new STFSlider(this);
-    layout->addWidget(m_stfSlider);
+    addWidget(m_stfSlider);
     connect(m_stfSlider, SIGNAL(paramChanged(float, float, float)), this, SIGNAL(paramChanged(float,float,float)));
 
-    QToolButton *autoStretchButton = new QToolButton(this);
-    autoStretchButton->setIcon(QIcon(":/nuke.png"));
-    autoStretchButton->setToolTip(tr("Auto Stretch F12"));
+    QAction *autoStretchButton = addAction(QIcon(":/nuke.png"), tr("Auto Stretch F12"));
     autoStretchButton->setShortcut(Qt::Key_F12);
-    connect(autoStretchButton, SIGNAL(pressed()), this, SIGNAL(autoStretch()));
+    connect(autoStretchButton, SIGNAL(triggered()), this, SIGNAL(autoStretch()));
 
-    QToolButton *resetButton = new QToolButton(this);
-    resetButton->setIcon(style()->standardIcon(QStyle::SP_DialogResetButton));
-    resetButton->setToolTip(tr("Reset Screen Transfer Function F11"));
+    QAction *resetButton = addAction(style()->standardIcon(QStyle::SP_DialogResetButton), tr("Reset Screen Transfer Function F11"));
     resetButton->setShortcut(Qt::Key_F11);
-    connect(resetButton, &QToolButton::pressed, this, &StretchPanel::resetMTF);
+    connect(resetButton, &QAction::triggered, this, &StretchToolbar::resetMTF);
 
-    QToolButton *invertButton = new QToolButton(this);
-    invertButton->setIcon(QIcon(":/invert.png"));
+    QAction *invertButton = addAction(QIcon(":/invert.png"), tr("Invert colors"));
     invertButton->setCheckable(true);
     connect(invertButton, SIGNAL(toggled(bool)), this, SIGNAL(invert(bool)));
 
-    QToolButton *superPixelButton = new QToolButton(this);
-    superPixelButton->setIcon(QIcon(":/bayer.png"));
+    QAction *superPixelButton = addAction(QIcon(":/bayer.png"), tr("Superpixel CFA draw 2x2 pixel as one"));
     superPixelButton->setCheckable(true);
-    superPixelButton->setToolTip(tr("Superpixel CFA draw 2x2 pixel as one"));
     connect(superPixelButton, SIGNAL(toggled(bool)), this, SIGNAL(superPixel(bool)));
-
-    layout->addWidget(autoStretchButton);
-    layout->addWidget(resetButton);
-    layout->addWidget(invertButton);
-    layout->addWidget(superPixelButton);
 }
 
-void StretchPanel::stretchImage(Image *img)
+void StretchToolbar::stretchImage(Image *img)
 {
     if(img)
     {
@@ -71,7 +57,7 @@ void StretchPanel::stretchImage(Image *img)
     }
 }
 
-void StretchPanel::resetMTF()
+void StretchToolbar::resetMTF()
 {
     m_stfSlider->setMTFParams(0, 0.5, 1);
     emit paramChanged(0, 0.5, 1);

stretchtoolbar.h

@@ -1,17 +1,17 @@
-#ifndef STRETCHPANEL_H
-#define STRETCHPANEL_H
+#ifndef STRETCHTOOLBAR_H
+#define STRETCHTOOLBAR_H
 
-#include <QWidget>
+#include <QToolBar>
 #include "stfslider.h"
 
 class Image;
 
-class StretchPanel : public QWidget
+class StretchToolbar : public QToolBar
 {
     Q_OBJECT
     STFSlider *m_stfSlider;
 public:
-    explicit StretchPanel(QWidget *parent = nullptr);
+    explicit StretchToolbar(QWidget *parent = nullptr);
 public slots:
     void stretchImage(Image *img);
     void resetMTF();
@@ -22,4 +22,4 @@ signals:
     void superPixel(bool enable);
 };
 
-#endif // STRETCHPANEL_H
+#endif // STRETCHTOOLBAR_H

thumb.frag

@@ -0,0 +1,21 @@
+#version 330
+
+uniform sampler2DArray qt_Texture0;
+uniform vec3 mtf_param;
+uniform bool invert;
+in vec3 qt_TexCoord0;
+out vec4 color;
+
+vec4 MTF(vec4 x, vec3 m)
+{
+    x = (x - m.x) / (m.z - m.x);
+    x = clamp(x, vec4(0.0), vec4(1.0));
+    return ((m.y - 1) * x) / ((2 * m.y - 1) * x - m.y);
+}
+
+void main(void)
+{
+    color = texture(qt_Texture0, qt_TexCoord0);
+    color = MTF(color, mtf_param);
+    if(invert)color = vec4(1.0) - color;
+}

thumb.vert

@@ -0,0 +1,20 @@
+#version 330
+
+in vec2 qt_Vertex;
+in vec2 qt_MultiTexCoord0;
+in ivec3 imageSize_num;
+out vec3 qt_TexCoord0;
+uniform ivec3 viewport_row;
+uniform mat4 mvp;
+uniform vec2 offset;
+
+void main(void)
+{
+    vec2 pos = qt_Vertex * 0.5;
+    pos.y *= -1.0;
+    pos = pos * imageSize_num.xy + 69;
+    ivec2 off = ivec2(imageSize_num.z % viewport_row.z, imageSize_num.z / viewport_row.z) * 138;
+
+    gl_Position = mvp * vec4(pos - offset + off, 0.0, 1.0);
+    qt_TexCoord0 = vec3(qt_MultiTexCoord0, imageSize_num.z + 0.1);
+}