Implement fits_memfile workaround

CFITSIO doesn't support non-ASCI characters in file paths

CMakeLists.txt

@@ -39,6 +39,7 @@ set(TENMON_SRC
     src/filemanager.h src/filemanager.cpp src/filemanager.ui
     src/filesystemwidget.cpp src/filesystemwidget.h
     src/fitskeyword.ui
+    src/fitswrapper.h src/fitswrapper.cpp
     src/histogram.cpp src/histogram.h
     src/httpdownloader.h src/httpdownloader.cpp
     src/imageinfo.cpp src/imageinfo.h

src/fitswrapper.cpp

@@ -0,0 +1,89 @@
+#include "fitswrapper.h"
+#include <QDebug>
+#include <QFile>
+
+FITSWrapper::FITSWrapper(const QString &path, int mode, bool open)
+{
+    _path = path;
+    _mode = mode;
+
+    if(open)
+        fits_open_diskfile(&_file, path.toLocal8Bit().data(), mode, &_status);
+    else
+        fits_create_diskfile(&_file, path.toLocal8Bit().data(), &_status);
+
+    if(_status == FILE_NOT_OPENED || _status == FILE_NOT_CREATED)
+    {
+        qWarning() << "Could not open file directly trying memfile workaround" << path;
+        if(open)
+        {
+            QFile fr(path);
+            if(fr.open(QIODevice::ReadOnly))
+            {
+                _bufferSize = fr.size();
+                _bufferPtr = malloc(_bufferSize);
+                fr.read((char*)_bufferPtr, _bufferSize);
+                _status = 0;
+                fits_open_memfile(&_file, "memfile", mode, &_bufferPtr, &_bufferSize, 0, realloc, &_status);
+                if(_status)
+                {
+                    free(_bufferPtr);
+                    _bufferPtr = nullptr;
+                    _bufferSize = 0;
+                    qWarning() << "fits_open_memfile failed";
+                }
+            }
+            else
+            {
+                qWarning() << "QFile failed to open file" << path;
+                _status = FILE_NOT_OPENED;
+            }
+        }
+        else
+        {
+            _bufferSize = 2880;
+            _bufferPtr = malloc(_bufferSize);
+            fits_create_memfile(&_file, &_bufferPtr, &_bufferSize, 0, realloc, &_status);
+            if(_status)
+            {
+                free(_bufferPtr);
+                _bufferPtr = nullptr;
+                _bufferSize = 0;
+            }
+        }
+    }
+}
+
+FITSWrapper::~FITSWrapper()
+{
+    if(_file)
+    {
+        _status = 0;
+        fits_close_file(_file, &_status);
+    }
+
+    if(_mode == READWRITE && _bufferPtr)
+    {
+        qDebug() << "Writing FITS memfile" << _bufferSize;
+        QFile fw(_path);
+        if(fw.open(QIODevice::WriteOnly | QIODevice::Truncate))
+        {
+            if(fw.write((char*)_bufferPtr, _bufferSize) != (qint64)_bufferSize)
+                qWarning() << "Failed to write to file";
+        }
+        else
+            qWarning() << "Failed to open fits file for writing";
+    }
+
+    free(_bufferPtr);
+}
+
+int FITSWrapper::status() const
+{
+    return _status;
+}
+
+FITSWrapper::operator fitsfile *()
+{
+    return _file;
+}

src/fitswrapper.h

@@ -0,0 +1,25 @@
+#ifndef FITSWRAPPER_H
+#define FITSWRAPPER_H
+
+#include <QByteArray>
+#include <QString>
+#include <fitsio.h>
+
+class FITSWrapper
+{
+public:
+    explicit FITSWrapper(const QString &path, int mode, bool open);
+    ~FITSWrapper();
+    FITSWrapper(FITSWrapper &other) = delete;
+    int status() const;
+    operator fitsfile*();
+private:
+    QString _path;
+    int _status = 0;
+    int _mode = 0;
+    fitsfile *_file;
+    size_t _bufferSize = 0;
+    void *_bufferPtr = nullptr;
+};
+
+#endif // FITSWRAPPER_H

src/loadimage.cpp

@@ -1,13 +1,13 @@
 #include "loadimage.h"
-#include <QElapsedTimer>
-#include <QDebug>
-#include <QFileInfo>
-#include <QDir>
-#include <libraw/libraw.h>
-#include <fitsio2.h>
 #include "libxisf.h"
-#include <libexif/exif-data.h>
 #include "rawimage.h"
+#include <QDebug>
+#include <QDir>
+#include <QElapsedTimer>
+#include <QFileInfo>
+#include <libexif/exif-data.h>
+#include <libraw/libraw.h>
+#include "fitswrapper.h"
 
 QString makeUNCPath(const QString &path)
 {
@@ -85,7 +85,6 @@ int loadFITSHeader(fitsfile *file, ImageInfoData &info)
 
 bool loadFITS(const QString path, ImageInfoData &info, std::shared_ptr<RawImage> &image, bool planar, uint32_t index)
 {
-    fitsfile *file;
     int status = 0;
     int num = 0;
     long naxes[3] = {0};
@@ -99,29 +98,9 @@ bool loadFITS(const QString path, ImageInfoData &info, std::shared_ptr<RawImage>
         return false;
     };
 
-    fits_open_diskfile(&file, path.toLocal8Bit().data(), READONLY, &status);
+    FITSWrapper file(path, READONLY, true);
+    status = file.status();
 
-    QByteArray buffer;
-    size_t bufferSize = 0;
-    void *bufferPtr = nullptr;
-    if(status == FILE_NOT_OPENED)
-    {
-        qWarning() << "Could not open file directly tring memfile workaround" << path;
-        QFile fr(path);
-        if(fr.open(QIODevice::ReadOnly))
-        {
-            buffer = fr.readAll();
-            bufferSize = buffer.size();
-            bufferPtr = buffer.data();
-            status = 0;
-            fits_open_memfile(&file, "memfile", READONLY, &bufferPtr, &bufferSize, 0, NULL, &status);
-        }
-        else
-        {
-            qWarning() << "QFile failed to open file" << path;
-            return false;
-        }
-    }
     if(status)return checkError();
     fits_get_num_hdus(file, &num, &status);
     if(status)return checkError();
@@ -244,7 +223,6 @@ noload:
         }
     }
 
-    fits_close_file(file, &status);
     return true;
 }
 
@@ -253,7 +231,8 @@ bool loadXISF(const QString &path, ImageInfoData &info, std::shared_ptr<RawImage
     try
     {
         LibXISF::XISFReader xisf;
-        xisf.open(path.toLocal8Bit().data());
+        QFileInfo fileInfo(path);
+        xisf.open(fileInfo.filesystemFilePath());
 
         if(index >= (uint32_t)xisf.imagesCount())return false;
         const LibXISF::Image &xisfImage = xisf.getImage(index);
@@ -366,37 +345,14 @@ bool loadXISF(const QString &path, ImageInfoData &info, std::shared_ptr<RawImage
 
 bool readFITSHeader(const QString &path, ImageInfoData &info)
 {
-    fitsfile *file;
-    int status = 0;
     QString path2 = makeUNCPath(path);
-    fits_open_diskfile(&file, path2.toLocal8Bit().data(), READONLY, &status);
 
-    QByteArray buffer;
-    size_t bufferSize = 0;
-    void *bufferPtr = nullptr;
-    if(status == FILE_NOT_OPENED)
-    {
-        qWarning() << "Could not open file directly tring memfile workaround" << path;
-        QFile fr(path);
-        if(fr.open(QIODevice::ReadOnly))
-        {
-            buffer = fr.readAll();
-            bufferSize = buffer.size();
-            bufferPtr = buffer.data();
-            status = 0;
-            fits_open_memfile(&file, "memfile", READONLY, &bufferPtr, &bufferSize, 0, NULL, &status);
-        }
-        else
-        {
-            qWarning() << "QFile failed to open file" << path;
-            return false;
-        }
-    }
+    FITSWrapper file(path, READONLY, true);
+    int status = file.status();
 
     if(file && status == 0)
     {
         status = loadFITSHeader(file, info);
-        fits_close_file(file, &status);
     }
     return status == 0;
 }
@@ -407,7 +363,8 @@ bool readXISFHeader(const QString &path, ImageInfoData &info)
     try
     {
         LibXISF::XISFReader xisf;
-        xisf.open(path2.toLocal8Bit().data());
+        QFileInfo fileInfo(path2);
+        xisf.open(fileInfo.filesystemFilePath());
         const LibXISF::Image &image = xisf.getImage(0, false);
 
         auto fitskeywords = image.fitsKeywords();

src/loadrunable.cpp

@@ -1,13 +1,14 @@
 #include "loadrunable.h"
+#include "fitswrapper.h"
 #include "imageringlist.h"
+#include "loadimage.h"
+#include "rawimage.h"
+#include <QDebug>
+#include <QElapsedTimer>
 #include <QFileInfo>
 #include <QPainter>
-#include <QElapsedTimer>
-#include <QDebug>
 #include <algorithm>
 #include <fitsio2.h>
-#include "rawimage.h"
-#include "loadimage.h"
 #include <lcms2.h>
 
 LoadRunable::LoadRunable(const QString &file, Image *receiver, AnalyzeLevel level, int index, bool thumbnail) :
@@ -269,7 +270,8 @@ void ConvertRunable::run()
                     image.setByteshuffling(true);
 
                 xisf.writeImage(image);
-                xisf.save(m_outfile.toLocal8Bit().data());
+                QFileInfo fileInfo(makeUNCPath(m_outfile));
+                xisf.save(fileInfo.filesystemFilePath());
             }
             catch(LibXISF::Error &err)
             {
@@ -281,9 +283,10 @@ void ConvertRunable::run()
         if(m_format == "fits")
         {
             int status = 0;
-            fitsfile *fw;
             if(QFileInfo(m_outfile).exists())QFile::remove(m_outfile);
-            fits_create_diskfile(&fw, m_outfile.toLocal8Bit().data(), &status);
+            FITSWrapper fw(m_outfile, READWRITE, false);
+            if(fw.status())return;
+
             if(!m_params.compressionType.isEmpty())
             {
                 if(m_params.compressionType == "gzip")
@@ -292,7 +295,6 @@ void ConvertRunable::run()
                     fits_set_compression_type(fw, RICE_1, &status);
             }
             writeFITSImage(fw, rawimage, imageinfo);
-            fits_close_file(fw, &status);
             return;
         }
 

src/scriptengine.cpp

@@ -1,16 +1,17 @@
 #include "scriptengine.h"
-#include <QDir>
-#include <QFileInfo>
-#include <QDebug>
-#include <QInputDialog>
-#include <QJsonValue>
-#include <QJSValueIterator>
+#include "batchprocessing.h"
+#include "fitswrapper.h"
+#include "libxisf.h"
+#include "loadimage.h"
 #include "loadrunable.h"
 #include "rawimage.h"
-#include "loadimage.h"
-#include "batchprocessing.h"
+#include <QDebug>
+#include <QDir>
+#include <QFileInfo>
+#include <QInputDialog>
+#include <QJSValueIterator>
+#include <QJsonValue>
 #include <fitsio2.h>
-#include "libxisf.h"
 #ifdef PLATESOLVER
 #include "solver.h"
 #endif // PLATESOLVER
@@ -672,31 +673,11 @@ bool File::modifyFITSRecords(const FITSRecordModify *modify)
 
     if(isFITS(suffix()))
     {
-        fitsfile *file;
         int status = 0;
         QString path = makeUNCPath(_path);
-        fits_open_diskfile(&file, path.toLocal8Bit().data(), READWRITE, &status);
-        QByteArray buffer;
-        size_t bufferSize = 0;
-        void *bufferPtr = nullptr;
-        if(status == FILE_NOT_OPENED)
-        {
-            qWarning() << "Could not open file directly tring memfile workaround" << path;
-            QFile fr(path);
-            if(fr.open(QIODevice::ReadOnly))
-            {
-                buffer = fr.readAll();
-                bufferSize = buffer.size();
-                bufferPtr = buffer.data();
-                status = 0;
-                fits_open_memfile(&file, "memfile", READONLY, &bufferPtr, &bufferSize, 0, NULL, &status);
-            }
-            else
-            {
-                qWarning() << "QFile failed to open file" << path;
-                return false;
-            }
-        }
+        FITSWrapper file(path, READWRITE, true);
+        status = file.status();
+
         int num = 0;
         fits_get_num_hdus(file, &num, &status);
         if(status)
@@ -816,8 +797,7 @@ bool File::modifyFITSRecords(const FITSRecordModify *modify)
                 return false;
             }
         }
-        fits_close_file(file, &status);
-
+        if(status)qWarning() << "Failed to modify FITS header" << status;
         return status == 0;
     }
     else if(isXISF(suffix()))
@@ -825,9 +805,9 @@ bool File::modifyFITSRecords(const FITSRecordModify *modify)
         try
         {
             LibXISF::XISFModify modifyXISF;
-            QString in = makeUNCPath(absoluteFilePath());
-            QString out = in + "~";
-            modifyXISF.open(in.toLocal8Bit().data());
+            QFileInfo in(makeUNCPath(absoluteFilePath()));
+            QFileInfo out(in.absoluteFilePath() + "~");
+            modifyXISF.open(in.filesystemFilePath());
             qDebug() << "modify" << in << out;
 
             for(auto &remove : modify->_remove)
@@ -842,9 +822,9 @@ bool File::modifyFITSRecords(const FITSRecordModify *modify)
             for(auto &property : modify->_property)
                 modifyXISF.updateProperty(modify->_imageIdx, property);
 
-            modifyXISF.save(out.toLocal8Bit().toStdString());
+            modifyXISF.save(out.filesystemFilePath());
             modifyXISF.close();
-            std::filesystem::rename(out.toLocal8Bit().toStdString(), in.toLocal8Bit().toStdString());
+            std::filesystem::rename(out.filesystemFilePath(), in.filesystemFilePath());
             return true;
         }
         catch(std::filesystem::filesystem_error &err)

thumbnailer/main.cpp

@@ -1,6 +1,7 @@
 #include <vector>
 #include <string>
 #include <iostream>
+#include <fstream>
 #include "../src/rawimage.h"
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "stb_image_write.h"