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 <ciiLogManager.hpp>
 
#include <ifw/fnd/defs/dataType.hpp>
#include <ifw/fnd/defs/fits.hpp>
 
#include <ifw/core/utils/base/base.hpp>
 
#include <ifw/core/dit/did/did.hpp>
 
 
namespace ifw::core::dit::fits {
 
    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;
 
    int DidToCfitsioType(const ifw::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 ifw::core::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 ifw::core::dit::did::Did& dictionary,
                          const std::string& key,
                          const int16_t hdu_nb,
                          ifw::core::dit::did::Record& did_record,
                          std::string& target_key,
                          bool& key_in_hdu);
 
    template <class TYPE>
    void AddKey(std::shared_ptr<CCfits::FITS>& fits_handle,
                const ifw::core::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() << ". Value: " << value);
 
      if ((typeid(TYPE) == typeid(double)) || (typeid(TYPE) == typeid(float))) {
          throw std::runtime_error("Use ifw::core::dit::fits::AddDoubleKey() for floating point type keyword "
            "cards (" + key + ")");
      }
 
      ifw::core::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()));
      }
    }
 
    void AddDoubleKey(std::shared_ptr<CCfits::FITS>& fits_handle,
                      const ifw::core::dit::did::Did& dictionary,
                      const std::string& key,
                      const double value,
                      const uint16_t hdu_nb);
 
    template <class TYPE>
    void UpdateKey(std::shared_ptr<CCfits::FITS>& fits_handle,
                   const ifw::core::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 update: \"" << key << "\". Type: " 
        << typeid(value).name());
 
      MoveToHdu(fits_handle, hdu_nb);
 
      ifw::core::dit::did::Record record;
      dictionary.LookUp(key, record);
      int cfitsio_type = DidToCfitsioType(record.GetDataType());
      int32_t status = 0;
      if (fits_update_key(fits_handle.get()->fitsPointer(), cfitsio_type, key.c_str(), (void*)&value,
                          record.GetComment().c_str(), &status) != 0) {
        std::string err = "executing cfitsio::fits_update_key()";
        HandleCfitsioError(err, status);
      }
    }
 
    int ReadIntKey(std::shared_ptr<CCfits::FITS>& fits_handle,
                const std::string& key);
 
    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,
                    const ifw::fnd::fits::BitPix bitpix,
                    const uint32_t image_size,
                    const void* image_buffer,
                    const int16_t hdu_nb = ifw::core::dit::fits::CUR_HDU,
                    const int16_t naxis3 = 0);
 
    void addHdu(std::shared_ptr<CCfits::FITS>& fits_handle,
                const std::string extension_name,
                const ifw::fnd::fits::BitPix bitpix,
                const std::vector<int32_t>& naxes);
}
 
#endif // IFW_DIT_FITS_HPP_