248 lines
8.1 KiB
C++
248 lines
8.1 KiB
C++
#include "loadrunable.h"
|
|
#include "imageringlist.h"
|
|
#include <libraw/libraw.h>
|
|
#include "imageinfo.h"
|
|
#include <QFileInfo>
|
|
#include <libexif/exif-data.h>
|
|
#include <fitsio2.h>
|
|
#include "rawimage.h"
|
|
|
|
LoadRunable::LoadRunable(const QString &file, Image *receiver, AnalyzeLevel level) :
|
|
m_file(file),
|
|
m_receiver(receiver),
|
|
m_analyzeLevel(level)
|
|
{
|
|
}
|
|
|
|
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)));
|
|
}
|
|
}
|
|
|
|
bool loadRAW(QString path, ImageInfoData &info, RawImageAbs **image, QImage *qimage)
|
|
{
|
|
if(!image && !qimage)
|
|
return false;
|
|
|
|
LibRaw raw;
|
|
raw.open_file(path.toLocal8Bit().data());
|
|
raw.imgdata.params.half_size = true;
|
|
raw.imgdata.params.use_camera_wb = true;
|
|
raw.imgdata.params.user_flip = 0;
|
|
if(raw.unpack())
|
|
return false;
|
|
|
|
if(image)
|
|
{
|
|
libraw_rawdata_t rawdata = raw.imgdata.rawdata;
|
|
size_t size = rawdata.sizes.width*rawdata.sizes.height;
|
|
|
|
std::vector<uint16_t> out;
|
|
out.resize(size);
|
|
size_t d = 0;
|
|
uint h=rawdata.sizes.top_margin+rawdata.sizes.height;
|
|
uint w=rawdata.sizes.left_margin+rawdata.sizes.width;
|
|
size_t pitch = rawdata.sizes.raw_pitch/sizeof(uint16_t);
|
|
|
|
for(size_t i=rawdata.sizes.top_margin;i<h;i++)
|
|
{
|
|
for(size_t o=rawdata.sizes.left_margin;o<w;o++)
|
|
{
|
|
uint16_t p = rawdata.raw_image[i*pitch+o];
|
|
out[d++] = p;
|
|
}
|
|
}
|
|
*image = new RawImage<uint16_t>(rawdata.sizes.width, rawdata.sizes.height, out);
|
|
}
|
|
|
|
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("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, RawImageAbs **image, QImage *qimage)
|
|
{
|
|
if(!image && !qimage)
|
|
return false;
|
|
|
|
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 && naxis <= 3 && status == 0)
|
|
{
|
|
std::vector<uint8_t> bits8;
|
|
std::vector<uint16_t> bits16;
|
|
std::vector<uint32_t> bits32;
|
|
long fpixel[3] = {1,1,1};
|
|
|
|
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)
|
|
{
|
|
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));
|
|
}
|
|
if(image)*image = new RawImage<uint8_t>(naxes[0], naxes[1], bits8);
|
|
break;
|
|
case SHORT_IMG:
|
|
bits16.resize(size);
|
|
fits_read_pix(file, TUSHORT, fpixel, size, NULL, &bits16[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] = bits16[i*w+o] >> 8;
|
|
}
|
|
}
|
|
if(image)*image = new RawImage<uint16_t>(naxes[0], naxes[1], bits16);
|
|
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<uint32_t>(naxes[0], naxes[1], bits32);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int nheader = 0, 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 true;
|
|
}
|
|
|
|
void LoadRunable::run()
|
|
{
|
|
if(!m_receiver->isCurrent())
|
|
{
|
|
return;
|
|
}
|
|
ImageInfoData info;
|
|
QFileInfo finfo(m_file);
|
|
info.append(StringPair(QObject::tr("Filename"), finfo.fileName()));
|
|
|
|
QImage img;
|
|
RawImageAbs *rawImage = nullptr;
|
|
if(m_file.endsWith(".CR2", Qt::CaseInsensitive))
|
|
{
|
|
loadRAW(m_file, info, m_analyzeLevel != None ? &rawImage : nullptr, &img);
|
|
}
|
|
else if(m_file.endsWith(".FIT", Qt::CaseInsensitive))
|
|
{
|
|
loadFITS(m_file, info, m_analyzeLevel != None ? &rawImage : nullptr, &img);
|
|
}
|
|
else
|
|
{
|
|
img = QImage(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);
|
|
exif_data_free(exif);
|
|
}
|
|
}
|
|
|
|
if(rawImage)
|
|
{
|
|
uint64_t mean, median, min, max;
|
|
double stdDev;
|
|
rawImage->imageStats(&mean, &stdDev, &median, &min, &max);
|
|
info.append(StringPair(QObject::tr("Mean"), QString::number(mean)));
|
|
info.append(StringPair(QObject::tr("Standart deviation"), QString::number(stdDev)));
|
|
info.append(StringPair(QObject::tr("Median"), QString::number(median)));
|
|
info.append(StringPair(QObject::tr("Minimum"), QString::number(min)));
|
|
info.append(StringPair(QObject::tr("Maximum"), QString::number(max)));
|
|
}
|
|
|
|
QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(QImage, img), Q_ARG(ImageInfoData, info));
|
|
}
|