cfitsio.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libfits
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Contains definitions for daq/fits/cfitsio.hpp
 */
#include <daq/fits/cfitsio.hpp>
 
#include <cassert>
#include <ostream>
 
#include <fmt/format.h>
#include <fmt/ostream.h>
 
namespace daq::fits {
namespace {
/**
 * Reads keywords from CHDU / Current HDU
 */
std::vector<LiteralKeyword> ReadCurrentHduKeywords(fitsfile* ptr) {
    assert(ptr);
    int status = 0;
    int count = 0;
    int more_space = 0;
    if (fits_get_hdrspace(ptr, &count, &more_space, &status) != 0) {
        throw CfitsioError(status, "Failed to get number of keywords in HDU");
    }
    std::vector<LiteralKeyword> keywords;
    keywords.reserve(count);
    for (int keynum = 1; keynum <= count; ++keynum) {
        try {
            char record[FLEN_CARD];
            if (fits_read_record(ptr, keynum, &record[0], &status) != 0) {
                throw CfitsioError(status, fmt::format("Failed to read record number {}", keynum));
            }
            // note: FITS returns null-terminated string
            keywords.emplace_back(std::string_view(record));
        } catch (...) {
            std::throw_with_nested(CfitsioError(
                status,
                fmt::format("Failed to read recordd number {} as literal keyword", keynum)));
        }
    }
    return keywords;
}
 
std::string FitsErrorMessage(int status) {
    char msg[FLEN_STATUS];
    fits_get_errstatus(status, &msg[0]);
    return std::string(msg);
}
 
}  // namespace
 
std::ostream& operator<<(std::ostream& os, HduType hdu_type) {
    switch (hdu_type) {
    case HduType::Image:
        os << "Image";
        break;
    case HduType::Ascii:
        os << "Ascii";
        break;
    case HduType::Binary:
        os << "Binary";
        break;
    default:
        os << "Unknown";
        break;
    };
    return os;
}
 
MemoryFitsFile::MemoryFitsFile() noexcept : m_memory(), m_file(nullptr, fits::DefaultClose) {
}
 
MemoryFitsFile::MemoryFitsFile(std::size_t initial_buffer_size)
    : m_memory(std::make_unique<FitsMemory>(initial_buffer_size))
    , m_file(nullptr, fits::DefaultClose) {
    fitsfile* ptr = nullptr;
    int status = 0;
    fits_create_memfile(&ptr, &m_memory->buffer, &m_memory->size, 0u, realloc, &status);
 
    m_file.reset(ptr);
}
 
MemoryFitsFile::FitsMemory::FitsMemory(std::size_t initial_size) {
    size = initial_size;
    buffer = malloc(size);
    memset(buffer, 0u, size);
}
 
MemoryFitsFile::FitsMemory::~FitsMemory() noexcept {
    int status = 0;
    fits_free_memory(buffer, &status);
}
 
CfitsioError::CfitsioError(int status, char const* message)
    : std::runtime_error(fmt::format("{}: {}", message, FitsErrorMessage(status)).c_str())
    , m_status(status) {
}
 
CfitsioError::CfitsioError(int status, std::string const& message)
    : std::runtime_error(fmt::format("{}: {}", message, FitsErrorMessage(status)).c_str())
    , m_status(status) {
}
 
void SelectHduNum(fitsfile* ptr, int hdu_num) {
    assert(ptr);
    int status = 0;
    int type = 0;
    (void)fits_movabs_hdu(ptr, hdu_num, &type, &status);
    if (status != 0) {
        throw CfitsioError(status,
                           fmt::format("HDU with number {} could not be selected", hdu_num));
    }
}
 
void DefaultClose(fitsfile* ptr) noexcept {
    if (ptr == nullptr) {
        return;
    }
    int status = 0;
    fits_close_file(ptr, &status);
}
 
int CfitsioError::GetStatus() const noexcept {
    return m_status;
}
 
void InitPrimaryHduEmpty(fitsfile* ptr) {
    int status = 0;
    int num_hdus = 0;
    (void)fits_get_num_hdus(ptr, &num_hdus, &status);
    if (num_hdus != 0) {
        throw CfitsioError(HEADER_NOT_EMPTY, "Cannot safely initialize an non-empty FITS file");
    }
    (void)fits_create_hdu(ptr, &status);
    if (status != 0) {
        throw CfitsioError(status, "Failed to create HDU");
    }
}
 
void InitPrimaryHduNoImage(fitsfile* ptr) {
    /*
    SIMPLE  =                    T / file does conform to FITS standard
    BITPIX  =                    8 / number of bits per data pixel
    NAXIS   =                    0 / number of data axes
    */
    assert(ptr);
    int status = 0;
    int simple = true;
    int extend = true;
    char bitpix = 8;
    char naxis = 0;
    int num_hdus = 0;
    (void)fits_get_num_hdus(ptr, &num_hdus, &status);
    if (num_hdus != 0) {
        throw CfitsioError(HEADER_NOT_EMPTY, "Cannot safely initialize an non-empty FITS file");
    }
    (void)fits_create_hdu(ptr, &status);
    (void)fits_write_key(
        ptr, TLOGICAL, "SIMPLE", &simple, "file does conform to FITS standard", &status);
    (void)fits_write_key(ptr, TBYTE, "BITPIX", &bitpix, "number of bits per data pixel", &status);
    (void)fits_write_key(
        ptr, TBYTE, "NAXIS", &naxis, "file provides primary HDU keywords only", &status);
    (void)fits_write_key(
        ptr, TLOGICAL, "EXTEND", &extend, "FITS Extension may be present", &status);
    if (status != 0) {
        char err_text[31];  // returns maximum 30 characters
        fits_get_errstatus(status, &err_text[0]);
        err_text[30] = '\0';
        throw CfitsioError(status, fmt::format("failed to initialize primary HDU: {}", err_text));
    }
}
 
UniqueFitsFile CreateEmpty(char const* filename) {
    fitsfile* ptr = nullptr;
    int status = 0;
    fits_create_diskfile(&ptr, const_cast<char*>(filename), &status);
    if (status != 0 || ptr == nullptr) {
        throw CfitsioError(status, fmt::format("failed to create FITS file '{}'", filename));
    }
    return UniqueFitsFile(ptr, DefaultClose);
}
 
UniqueFitsFile Open(char const* filename, OpenMode mode) {
    fitsfile* ptr = nullptr;
    int status = 0;
    fits_open_diskfile(&ptr,
                       const_cast<char*>(filename),
                       mode == OpenMode::ReadWrite ? READWRITE : READONLY,
                       &status);
    if (status != 0 || ptr == nullptr) {
        throw CfitsioError(status, fmt::format("failed to open FITS file '{}'", filename));
    }
    return UniqueFitsFile(ptr, DefaultClose);
}
 
std::vector<LiteralKeyword> ReadKeywords(fitsfile* ptr, int hdu_num) {
    assert(ptr);
    SelectHduNum(ptr, hdu_num);
    return ReadCurrentHduKeywords(ptr);
}
 
std::vector<LiteralKeyword>
ReadKeywords(fitsfile* ptr, HduType type, std::string_view name, std::optional<int> version) {
    assert(ptr);
    int status = 0;
    // Makes sure string is null-terminated
    std::string null_terminated_name(name);
    (void)fits_movnam_hdu(ptr,
                          static_cast<int>(type),
                          const_cast<char*>(null_terminated_name.c_str()),
                          version.value_or(0),
                          &status);
    if (status != 0) {
        throw CfitsioError(
            status,
            fmt::format("HDU with type {}, name '{}' and version {} could not be selected",
                        fmt::streamed(type),
                        name,
                        version.value_or(0)));
    }
    return ReadCurrentHduKeywords(ptr);
}
 
void DeleteAllKeywords(fitsfile* ptr, int hdu_num) {
    assert(ptr);
    SelectHduNum(ptr, hdu_num);
 
    int status = 0;
    int num_current_keys = 0;
    // Reserve space for keys
    // If FITS file has not yet been closed for the first time it returns -1 for more_keys (likely
    // because it's still virtual).
    // We don't yet do anything, but could issue warning.
    fits_get_hdrspace(ptr, &num_current_keys, nullptr, &status);
    for (int keynum = num_current_keys; keynum > 0; --keynum) {
        fits_delete_record(ptr, keynum, &status);
        if (status != 0) {
            throw CfitsioError(status,
                               fmt::format("failed to delete keyword record index {}", keynum));
        }
    }
}
 
void MakeHduSpace(fitsfile* ptr, int hdu_num, std::size_t additional_keys) {
    assert(ptr);
    SelectHduNum(ptr, hdu_num);
 
    int status = 0;
    int num_current_keys = 0;
    int more_keys = additional_keys;
 
    // Reserve space for keys
    // If FITS file has not yet been closed for the first time it returns -1 for more_keys (likely
    // because it's still virtual).
    // We don't yet do anything, but could issue warning.
    fits_get_hdrspace(ptr, &num_current_keys, &more_keys, &status);
    if (status != 0) {
        throw CfitsioError(status, fmt::format("Failed to update header space"));
    }
}
 
void WriteKeywords(fitsfile* ptr,
                   int hdu_num,
                   std::vector<LiteralKeyword> const& keywords,
                   std::optional<ssize_t>* remaining_size) {
    assert(ptr);
    SelectHduNum(ptr, hdu_num);
    std::string null_terminated_record;
    null_terminated_record.reserve(FLEN_CARD);
    int status = 0;
    int num_current_keys = 0;
    int more_keys = keywords.size();
    // Reserve space for keys
    // If FITS file has not yet been closed for the first time it returns -1 for more_keys (likely
    // because it's still virtual).
    // We don't yet do anything, but could issue warning.
    fits_get_hdrspace(ptr, &num_current_keys, &more_keys, &status);
    if (status != 0) {
        throw CfitsioError(status, fmt::format("Failed to get header space"));
    }
 
    if (remaining_size != nullptr && more_keys != -1) {
        *remaining_size = more_keys - keywords.size();
    }
 
    for (auto const& kw : keywords) {
        null_terminated_record.assign(kw.GetRecord());
        // note: Unclear it fits requires null terminated record or not...
        fits_write_record(ptr, null_terminated_record.c_str(), &status);
        if (status != 0) {
            throw CfitsioError(
                status,
                fmt::format("Failed to write keyword record: \"{}\"", null_terminated_record));
        }
    }
}
 
void WriteChecksum(fitsfile* ptr, int hdu_num) {
    assert(ptr);
    SelectHduNum(ptr, hdu_num);
    int status = 0;
    fits_write_chksum(ptr, &status);
    if (status != 0) {
        throw CfitsioError(
            status, fmt::format("Failed to write checksum keywords to HDU number {}", hdu_num));
    }
}
 
}  // namespace daq::fits