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 <core/utils/base/base.hpp>
 
#include <core/dit/did/did.hpp>
 
 
namespace core::dit::fits {
 
    //static constexpr const char* LOG_PROPERTIES_FILE = "config/core/dit/fitslib/log.properties";
    log4cplus::Logger& Logger();
 
    using CfitsioType = int32_t;
 
    const int CUR_HDU = -1;
    const int APPEND = -2;
 
    const std::string FITS_KEY_ESO_HIERARCH = "HIERARCH ESO";
    const int16_t     ALL_HEADERS = SHRT_MAX;
    const int         BITS_PER_PIXEL = 8;
 
 
 
    //CfitsioType DidToCfitsioType(const core::dit::did::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(std::shared_ptr<CCfits::FITS>& fits_handle,
                    const std::string& filename,
                    const dit::did::Did& dictionary,
                    const int32_t bitpix,
                    const std::vector<int32_t>& naxes,
                    std::string& target_filename,
                    const bool remove_if_exists = false,
                    const uint16_t nb_of_hdr_blocks = 1);
 
    void OpenFitsFile(std::shared_ptr<CCfits::FITS>& fits_handle,
                      const std::string& filename,
                      std::string& target_filename,
                      CCfits::RWmode mode = CCfits::Read);
 
    bool KeyInHdu(std::shared_ptr<CCfits::FITS>& fits_handle,
                  const int16_t hdu_nb,
                  const std::string& key);
 
    void MoveToHdu(std::shared_ptr<CCfits::FITS>& fits_handle,
                   const int16_t hdu_nb);
 
    struct FormatSpec {
      std::string m_prefix;
      int         m_precision;
      std::string m_format;
    };
 
    void PrepForAddingKey(std::shared_ptr<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);
 
    // TODO: Move template code to separate header files.
    template <class TYPE>
    void AddKey(std::shared_ptr<CCfits::FITS>& fits_handle,
                const dit::did::Did& dictionary,
                const std::string& key,
                const TYPE& value,
                const int16_t hdu_nb = CUR_HDU) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
 
      LOG4CPLUS_DEBUG(Logger(), "Keyword to add: \"" << key << "\". Type: " 
        << typeid(value).name());
 
      if ((typeid(TYPE) == typeid(double)) || (typeid(TYPE) == typeid(float))) {
          throw std::runtime_error("Use dit::fits::AddDoubleKey() for floating point type keyword "
            "cards (" + key + ")");
      }
 
      dit::did::Record did_record;
      std::string target_key;
      bool key_in_hdu;
      PrepForAddingKey(fits_handle, dictionary, key, hdu_nb, did_record, target_key, key_in_hdu);
 
      int cur_hdu;
      fits_get_hdu_num(fits_handle.get()->fitsPointer(), &cur_hdu);
      try {
        if (cur_hdu == 1) {
            fits_handle.get()->pHDU().addKey(target_key, value, did_record.GetComment());
          } else {
            fits_handle.get()->extension(cur_hdu-1).addKey(target_key, value, did_record.GetComment());
          }
      } catch (CCfits::FitsException& ex) {
        throw std::runtime_error(fmt::format("Error adding key: \"{}\". Diagnostics: {}.",
          key, ex.message()));
      }
    }
 
    int ReadIntKey(std::shared_ptr<CCfits::FITS>& fits_handle,
                const std::string& key);
 
    void AddDoubleKey(std::shared_ptr<CCfits::FITS>& fits_handle,
                      const dit::did::Did& dictionary,
                      const std::string& key,
                      const double value,
                      const uint16_t hdu_nb);
 
    void ExtractHeaders(const std::string& filename,
                        std::string& target_filename,
                        std::string& hdr_buf,
                        const int16_t hdr_ref = ALL_HEADERS);
 
    void ExtractHeaders(std::shared_ptr<CCfits::FITS>& fits_handle,
                        std::string& hdr_buf,
                        const int16_t hdr_ref = ALL_HEADERS);
 
    void StoreImage(std::shared_ptr<CCfits::FITS>& fits_handle,
                    int8_t bitpix,
                    uint32_t image_size,
                    const void* image_buffer,
                    int16_t hdu_nb = core::dit::fits::CUR_HDU,
                    int16_t naxis3 = 0);
    int BitpixToCfitsioDataType(const int8_t bitpix);
 
    void addHDU(std::shared_ptr<CCfits::FITS>& fits_handle, std::string extensionName,
            int8_t bitpix, const std::vector<int32_t>& naxes);
}
 
#endif // IFW_DIT_FITS_HPP_