fits.hpp

Go to the documentation of this file.

#ifndef IFW_DIT_FITS_HPP_
#define IFW_DIT_FITS_HPP_

#include <string>

#include <fitsio.h>
#include <CCfits/CCfits.h>
#include <CCfits/FITS.h>
#include <CCfits/PHDU.h>

#include "ctd/defines/defines.hpp"

#include "dit/did/Did.hpp"


namespace dit {
namespace fits {

using CfitsioType = int32_t;

const std::string FITS_KEY_ESO_HIERARCH = "HIERARCH ESO";
const int16_t     ALL_HEADERS = SHRT_MAX;

CfitsioType DidToCfitsioType(ctd::defines::DataType did_type);


void HandleCfitsioError(const std::string& operation,
                        const int cfitsio_status);


std::string GenerateKey(const std::string& key,
                        const std::string& hierarch_prefix = FITS_KEY_ESO_HIERARCH);


void CreateFile(CCfits::FITS** fits_handle,
                const std::string& filename,
                const dit::did::Did& dictionary,
                const int32_t bitpix,
                const std::list<int32_t>& naxes,
                std::string& target_filename,
                const bool remove_if_exists = false,
                const uint16_t nb_of_hdr_blocks = 1);

void OpenFitsFile(CCfits::FITS** fits_handle,
                  const std::string& filename,
                  std::string& target_filename,
                  CCfits::RWmode mode = CCfits::Read);

bool KeyInHdu(CCfits::FITS& fits_handle,
              const int16_t hdu_nb,
              const std::string& key);

void MoveToHdu(CCfits::FITS& fits_handle,
               const int16_t hdu_nb);

void PrepForAddingKey(CCfits::FITS& fits_handle,
                      const dit::did::Did& dictionary,
                      const std::string& key,
                      const int16_t hdu_nb,
                      dit::did::Record& did_record,
                      std::string& target_key,
                      bool& key_in_hdu,
                      CfitsioType& cfitsio_type,
                      dit::did::FormatSpecifier& format_specifier);

template <class TYPE> void AddKey(CCfits::FITS& fits_handle,
                                  const dit::did::Did& dictionary,
                                  const std::string& key,
                                  const TYPE& value,
                                  const int16_t hdu_nb) {
    RAD_LOG_TRACE();

    RAD_LOG_DEBUG1() << "Keyword to add: \"" << key << "\". Type: " << typeid(value).name();

    if ((typeid(TYPE) == typeid(double)) || (typeid(TYPE) == typeid(float))) {
        throw rad::Exception("Use dit::fits::AddDoubleKey() for floating point "
                             "type keyword cards");
    }

    dit::did::Record did_record;
    std::string target_key;
    bool key_in_hdu;
    CfitsioType cfitsio_type;
    dit::did::FormatSpecifier format_spec;
    PrepForAddingKey(fits_handle, dictionary, key, hdu_nb, did_record, target_key, key_in_hdu,
                     cfitsio_type, format_spec);

    try {
        if (hdu_nb == 1) {
            fits_handle.pHDU().addKey(target_key, value, did_record.GetComment());
        } else {
            fits_handle.extension(hdu_nb).addKey(target_key, value, did_record.GetComment());
        }
    } catch (CCfits::FitsException& ex) {
        throw rad::Exception(ifw::Print("Error adding key: \"%s\". Diagnostics: %s.",
                                        key.c_str(), ex.message().c_str()));
    }
}


void AddDoubleKey(CCfits::FITS& fits_handle,
                  const dit::did::Did& dictionary,
                  const std::string& key,
                  const double value,
                  const uint16_t hdu_nb);


class FitsReport {
public:
    FitsReport() {};
    ~FitsReport() {};
private:
};


void Verify(const std::string& filename,
            std::string& target_filename,
            dit::fits::FitsReport& report);

void Verify(const std::string& filename,
            std::string& target_filename,
            const dit::did::Did& dictionary,
            dit::fits::FitsReport& report);

void ExtractHeaders(const std::string& filename,
                    std::string& target_filename,
                    std::string& hdr_buf,
                    const int16_t hdr_ref = ALL_HEADERS);

void ExtractHeaders(CCfits::FITS& fits_handle,
                    std::string& hdr_buf,
                    const int16_t hdr_ref = ALL_HEADERS);

} // namespace fits
} // namespace ctd

#endif // IFW_DIT_FITS_HPP_