CArcFitsFile.h

// +------------------------------------------------------------------------------------------------------------------+
// |  FILE:  CArcFitsFile.h  ( GenIV )                                                                                |
// +------------------------------------------------------------------------------------------------------------------+
// |  PURPOSE: This file defines the standard ARC FITS interface.                                                     |
// |                                                                                                                  |
// |  AUTHOR:  Scott Streit         DATE: October 03, 2014                                                            |
// |                                                                                                                  |
// |  Copyright 2013 Astronomical Research Cameras, Inc. All rights reserved.                                         |
// +------------------------------------------------------------------------------------------------------------------+
#pragma once
 
#ifdef _WINDOWS
    #pragma warning( disable: 4251 )
#endif
 
 
#include <version>
#include <filesystem>
#include <stdexcept>
#include <cstdint>
#include <utility>
#include <memory>
#include <string>
 
#if __cpp_lib_variant
    #include <variant>
#else
    #include <tuple>
#endif
 
#include <CArcFitsFileDllMain.h>
#include <CArcStringList.h>
#include <CArcBase.h>
 
#include <fitsio.h>     // This header MUST be last to prevent winnt.h constant error!
 
using namespace std::string_literals;
 
 
 
namespace arc
{
    namespace gen4
    {
 
        namespace fits
        {
 
            using BPP_16 = std::uint16_t;
 
            using BPP_32 = std::uint32_t;
 
 
            #if __cpp_lib_variant
                using keywordValue_t = std::variant<std::uint32_t, std::int32_t, std::uint64_t, std::int64_t, double, std::string>;
            #else
                using keywordValue_t = std::tuple<std::uint32_t, std::int32_t, std::uint64_t, std::int64_t, double, std::string>;
            #endif
 
 
            enum class fitsMode_e : std::int32_t
            {
                READMODE        = READONLY,
                READWRITEMODE   = READWRITE
            };
 
 
            enum class fitsKeyType_e : std::int32_t
            {
                FITS_INVALID_KEY = -1,      
                FITS_STRING_KEY = 0,        
                FITS_INT_KEY,               
                FITS_UINT_KEY,              
                FITS_SHORT_KEY,             
                FITS_USHORT_KEY,            
                FITS_FLOAT_KEY,             
                FITS_DOUBLE_KEY,            
                FITS_BYTE_KEY,              
                FITS_LONG_KEY,              
                FITS_ULONG_KEY,             
                FITS_LONGLONG_KEY,          
                FITS_LOGICAL_KEY,           
                FITS_COMMENT_KEY,           
                FITS_HISTORY_KEY,           
                FITS_DATE_KEY               
            };
 
 
            struct GEN4_CARCFITSFILE_API fitsParameter_t final
            {
                long m_lNAxes[ 3 ];
 
                int m_iNAxis;
 
                int m_iBpp;
            };
 
 
            const std::string toString( const fitsParameter_t& tParam );
 
 
            template <typename T>
            struct GEN4_CARCFITSFILE_API ArrayDeleter
            {
                void operator()( T* p ) const
                {
                    if ( p != nullptr )
                    {
                        delete [] p;
                    }
                }
            };
 
 
            // +----------------------------------------------------------------------------------------------------------+
            // |  Definitions for Point data type                                                                         |
            // +----------------------------------------------------------------------------------------------------------+
 
            using point_t = std::pair<long, long>;
 
 
            constexpr auto MAKE_POINT( std::uint32_t uiColumn, std::uint32_t uiRow ) { return std::make_pair( uiColumn, uiRow ); }
 
        }   // end fits namespace
 
 
        template <typename T = arc::gen4::fits::BPP_16>
        class GEN4_CARCFITSFILE_API CArcFitsFile : public arc::gen4::CArcBase
        {
            public:
 
                CArcFitsFile( void );
 
                virtual ~CArcFitsFile( void );
 
                static const std::string version( void ) noexcept;
 
                static const std::string cfitsioVersion( void ) noexcept;
 
                const std::string getType( void ) const noexcept;
 
                void create( const std::filesystem::path& tFileName, std::uint32_t uiCols, std::uint32_t uiRows );
 
                void create3D( const std::filesystem::path& tFileName, std::uint32_t uiCols, std::uint32_t uiRows );
 
                void open( const std::filesystem::path& tFileName, arc::gen4::fits::fitsMode_e eMode = arc::gen4::fits::fitsMode_e::READMODE );
 
                void close( void ) noexcept;
 
                std::unique_ptr<arc::gen4::CArcStringList> getHeader( void ) const;
 
                const std::filesystem::path getFileName( void ) const;
 
                arc::gen4::fits::keywordValue_t readKeyword( const std::string& sKey, arc::gen4::fits::fitsKeyType_e eType ) const;
 
                void writeKeyword( const std::string& sKey, void* pValue, arc::gen4::fits::fitsKeyType_e eType, const std::string& sComment = ""s ) const;
 
                void updateKeyword( const std::string& sKey, void* pValue, arc::gen4::fits::fitsKeyType_e eType, const std::string& sComment = ""s ) const;
 
                std::unique_ptr<arc::gen4::fits::fitsParameter_t> getParameters( void ) const;
 
                std::uint32_t getNumberOfFrames( void ) const;
 
                std::uint32_t getRows( void ) const;
 
                std::uint32_t getCols( void ) const;
 
                std::uint32_t getNAxis( void ) const;
 
                std::uint32_t getBitsPerPixel( void ) const;
 
                void generateTestData( void ) const;
 
                void reOpen( void );
 
                void flush( void ) const;
 
                bool compare( CArcFitsFile<T>& cFitsFile ) const;
 
                void reSize( const std::uint32_t uiCols, const std::uint32_t uiRows );
 
                void write( const T* pBuf ) const;
 
                void write( const T* pBuf, const std::int64_t i64Bytes, const std::int64_t i64Pixel = 1 ) const;
 
                void writeSubImage( const T* pBuf, const arc::gen4::fits::point_t lowerLeftPoint, const arc::gen4::fits::point_t upperRightPoint ) const;
 
                std::unique_ptr<T[], arc::gen4::fits::ArrayDeleter<T>> readSubImage( arc::gen4::fits::point_t lowerLeftPoint, arc::gen4::fits::point_t upperRightPoint ) const;
 
                std::unique_ptr<T[], arc::gen4::fits::ArrayDeleter<T>> read( void ) const;
 
                void read( T* pBuf, const std::uint32_t uiCols, const std::uint32_t uiRows ) const;
 
                void write3D( const T* pBuf ) const;
 
                void reWrite3D( const T* pBuf, const std::uint32_t uiImageNumber ) const;
 
                std::unique_ptr<T[], arc::gen4::fits::ArrayDeleter<T>> read3D( std::uint32_t uiImageNumber ) const;
 
                fitsfile* getBaseFile( void ) const;
 
                std::uint32_t maxTVal( void ) const;
 
            private:
 
                inline void verifyFileHandle( void ) const;
 
                void throwFitsError( throwFormat_t<> tFormat, const std::int32_t iStatus ) const
                {
                    char szFitsMsg[ 100 ];
 
                    fits_get_errstatus( iStatus, szFitsMsg );
 
                    #ifdef __cpp_lib_format
 
                        throwArcGen4Error( tFormat, std::string( szFitsMsg ) );
 
                    #else
 
                        tFormat.m_format = "%s";
 
                        throwArcGen4Error( tFormat, szFitsMsg );
 
                    #endif
                }
 
                static const std::string m_sVersion;
 
                mutable std::int64_t m_i64Pixel;
 
                mutable std::int32_t m_iFrame;
 
                fitsfile* m_pFits;
            };
 
 
    }   // end gen4 namespace
}       // end arc namespace
 
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
namespace std
{
    template<>
    class GEN4_CARCFITSFILE_API default_delete< arc::gen4::fits::fitsParameter_t >
    {
        public:
 
            void operator()( arc::gen4::fits::fitsParameter_t* pObj );
    };
}
 
#endif      // DOXYGEN_SHOULD_SKIP_THIS