tenmon/loadrunable.cpp

#include "loadrunable.h"
#include "imageringlist.h"
#include <libraw/libraw.h>
#include "imageinfo.h"
#include <QFileInfo>
#include <libexif/exif-data.h>
#include <fitsio2.h>

LoadRunable::LoadRunable(const QString &file, Image *receiver) :
    m_file(file),
    m_receiver(receiver)
{
}

void loadExifEntry(ImageInfoData &info, ExifContent *content, ExifTag tag)
{
    char val[1024];
    ExifEntry *entry = exif_content_get_entry(content, tag);
    if(entry)
    {
        exif_entry_get_value(entry, val, sizeof(val));
        info.append(StringPair(exif_tag_get_title(tag), QString(val)));
    }
}

QImage loadFITS(QString path, ImageInfoData &info)
{
    QImage img;
    fitsfile *file;
    int status = 0;
    int type;
    fits_open_image(&file, path.toLocal8Bit().data(), READONLY, &status);
    fits_get_hdu_type(file, &type, &status);
    if(type == IMAGE_HDU)
    {
        int imgtype;
        int naxis;
        long naxes[2];
        fits_get_img_param(file, 2, &imgtype, &naxis, naxes, &status);

        if(naxis == 2)
        {
            std::vector<uint8_t> bits8;
            std::vector<uint16_t> bits16;
            std::vector<uint32_t> bits32;
            long fpixel[2] = {1,1};

            size_t size = naxes[0]*naxes[1];
            img = QImage(naxes[0], naxes[1], QImage::Format_Grayscale8);
            uchar *data = img.bits();
            info.append(StringPair(QObject::tr("Width"), QString::number(naxes[0])));
            info.append(StringPair(QObject::tr("Height"), QString::number(naxes[1])));

            switch(imgtype)
            {
            case BYTE_IMG:
                bits8.resize(size);
                fits_read_pix(file, TBYTE, fpixel, size, NULL, &bits8[0], NULL, &status);
                if(status)break;
                for(size_t i=0; i<size; i++)data[i] = bits8[i];
                break;
            case SHORT_IMG:
                bits16.resize(size);
                fits_read_pix(file, TUSHORT, fpixel, size, NULL, &bits16[0], NULL, &status);
                if(status)break;
                for(size_t i=0; i<size; i++)data[i] = bits16[i] >> 8;
                break;
            case LONG_IMG:
                bits32.resize(size);
                fits_read_pix(file, TUINT, fpixel, size, NULL, &bits32[0], NULL, &status);
                if(status)break;
                for(size_t i=0; i<size; i++)data[i] = bits32[i] >> 24;
                break;
            }
        }
    }

    int nheader, more;
    fits_get_hdrspace(file, &nheader, &more, &status);
    for(int i=1; i<=nheader; i++)
    {
        char key[FLEN_KEYWORD];
        char val[FLEN_VALUE];
        char comm[FLEN_COMMENT];
        fits_read_keyn(file, i, key, val, comm, &status);
        info.append(StringPair(key, QString(val)));
    }

    fits_close_file(file, &status);
    if(status)
    {
        char err[100];
        fits_get_errstatus(status, err);
        info.append(StringPair(QObject::tr("Error"), QString(err)));
    }

    return img;
}

void LoadRunable::run()
{
    if(!m_receiver->isCurrent())
    {
        return;
    }
    ImageInfoData info;
    QFileInfo finfo(m_file);
    info.append(StringPair(QObject::tr("Filename"), finfo.fileName()));

    if(m_file.endsWith(".CR2", Qt::CaseInsensitive))
    {
        LibRaw raw;
        raw.open_file(m_file.toLocal8Bit().data());
        raw.imgdata.params.half_size = true;
        raw.imgdata.params.use_camera_wb = true;
        raw.imgdata.params.user_flip = 0;
        raw.unpack();
        raw.dcraw_process();

        libraw_processed_image_t *rawImg = raw.dcraw_make_mem_image();
        QImage img(rawImg->width, rawImg->height, QImage::Format_RGB888);

        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);
        }

        uint scanLine = rawImg->width*rawImg->colors;
        for(uint i=0; i<rawImg->height; i++)
        {
            memcpy(img.scanLine(i), rawImg->data+(i*scanLine), scanLine);
        }
        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("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);
        QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(QImage, img), Q_ARG(ImageInfoData, info));
    }
    else if(m_file.endsWith(".FIT", Qt::CaseInsensitive))
    {
        QImage img = loadFITS(m_file, info);
        QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(QImage, img), Q_ARG(ImageInfoData, info));
    }
    else
    {
        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())));
        if(exif)
        {
            loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_ISO_SPEED_RATINGS);
            loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_SHUTTER_SPEED_VALUE);
        }
        QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(QImage, img), Q_ARG(ImageInfoData, info));
    }
}