fitsHeader.cpp

Go to the documentation of this file.

/** \file fitsHeader.cpp
 * \brief Implementation of a class to work with a FITS header
 * \ingroup fits_processing_files
 * \author Jared R. Males (jaredmales@gmail.com)
 *
 */
 
//***********************************************************************//
// Copyright 2015-2022 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#include "ioutils/fits/fitsHeader.hpp"
 
namespace mx
{
namespace fits
{
 
fitsHeader::fitsHeader()
{
}
 
fitsHeader::fitsHeader( const fitsHeader &head )
{
    operator=( head );
}
 
fitsHeader::~fitsHeader()
{
    clear();
}
 
fitsHeader &fitsHeader::operator=( const fitsHeader &head )
{
    cards = head.cards;
 
    headerIterator it = cards.begin();
 
    cardMap.clear();
    while( it != cards.end() )
    {
        cardMap.insert( std::pair<std::string, headerIterator>( it->keyword(), it ) );
        ++it;
    }
 
    return *this;
}
 
fitsHeader::headerIterator fitsHeader::begin()
{
    return cards.begin();
}
 
fitsHeader::headerIterator fitsHeader::end()
{
    return cards.end();
}
 
fitsHeader::headerIterator fitsHeader::iterator( const std::string &keyword )
{
    return cardMap.find( keyword )->second;
}
 
bool fitsHeader::empty()
{
    return cards.empty();
}
 
size_t fitsHeader::size()
{
    return cards.size();
}
 
void fitsHeader::clear()
{
    cards.clear();
    cardMap.clear();
}
 
size_t fitsHeader::count( const std::string &keyword )
{
    return cardMap.count( keyword );
}
 
void fitsHeader::erase( const std::string &keyword )
{
    if( keyword == "COMMENT" || keyword == "HISTORY" )
    {
        return;
    }
    headerIterator it;
    it = ( cardMap.find( keyword ) )->second; // trying to fool codacy
    cardMap.erase( keyword );
    cards.erase( it );
}
 
void fitsHeader::erase( headerIterator it )
{
    mapIterator mit = cardMap.find( it->keyword() );
 
    if( it->keyword() == "COMMENT" || it->keyword() == "HISTORY" )
    {
        while( mit->second->keyword() == it->keyword() && it->comment() != mit->second->comment() )
            ++mit;
    }
    cardMap.erase( mit );
    cards.erase( it );
}
 
void fitsHeader::eraseStandardTop()
{
 
    headerIterator it = begin(), nit;
 
    int n = 0;
    while( it != end() )
    {
        nit = it;
        ++nit;
        if( it->keyword() == "SIMPLE" || it->keyword() == "BITPIX" || it->keyword() == "NAXIS" ||
            it->keyword() == "NAXIS1" || it->keyword() == "NAXIS2" || it->keyword() == "NAXIS3" ||
            it->keyword() == "EXTEND" || it->keyword() == "BZERO" || it->keyword() == "BSCALE" ||
            it->keyword() == "LONGSTRN" )
        {
            erase( it );
        }
 
        if( it->keyword() == "COMMENT" )
        {
            if( it->comment().find( "FITS (Flexible Image" ) != std::string::npos )
                erase( it );
            else if( it->comment().find( "and Astrophysics'" ) != std::string::npos )
                erase( it );
        }
 
        if( nit == end() )
            break;
        it = nit;
        ++n;
    }
}
 
void fitsHeader::append( const fitsHeaderCard & card )
{
    // First check if duplicate key
    if( cardMap.count( card.keyword() ) > 0 )
    {
        if( card.type() != fitsType<fitsCommentType>() && card.type() != fitsType<fitsHistoryType>() )
        {
            std::cerr << "attempt to duplicate keyword: " << card.keyword() << "\n";
            return;
        }
    }
 
    // Now insert in list
    cards.push_back( card );
 
    // Then add to the Map.
    headerIterator insertedIt = cards.end();
    --insertedIt;
    cardMap.insert( std::pair<std::string, headerIterator>( card.keyword(), insertedIt ) );
}
 
void fitsHeader::append( fitsHeader &head )
{
    headerIterator it;
 
    for( it = head.begin(); it != head.end(); ++it )
    {
        append( *it );
    }
}
 
void fitsHeader::append( const std::string &k )
{
    append( fitsHeaderCard( k ) );
}
 
void fitsHeader::insert_before( headerIterator it, fitsHeaderCard card )
{
    // First check if duplicate key
    if( cardMap.count( card.keyword() ) > 0 )
    {
        if( card.type() != fitsType<fitsCommentType>() && card.type() != fitsType<fitsHistoryType>() )
        {
            std::cerr << "attempt to duplicate keyword: " << card.keyword() << "\n";
            return;
        }
    }
 
    // Now insert in list
    headerIterator insertedIt = cards.insert( it, card );
 
    // Then add to the Map.
    cardMap.insert( std::pair<std::string, headerIterator>( card.keyword(), insertedIt ) );
}
 
void fitsHeader::insert_after( headerIterator it, fitsHeaderCard card )
{
    // First check if duplicate key
    if( cardMap.count( card.keyword() ) > 0 )
    {
        if( card.type() != fitsType<fitsCommentType>() && card.type() != fitsType<fitsHistoryType>() )
        {
            std::cerr << "attempt to duplicate keyword:" << card.keyword() << "\n";
            return;
        }
    }
 
    // Now insert in list
    headerIterator insertedIt = cards.insert( ++it, card );
 
    // Then add to the Map.
    cardMap.insert( std::pair<std::string, headerIterator>( card.keyword(), insertedIt ) );
}
 
fitsHeaderCard &fitsHeader::operator[]( const std::string &keyword )
{
    headerIterator it;
 
    // If not found, append it.
    if( cardMap.find( keyword ) == cardMap.end() )
    {
        append( keyword );
    }
 
    it = cardMap.find( keyword )->second;
 
    return *it;
}
 
const fitsHeaderCard &fitsHeader::operator[]( const std::string &keyword ) const
{
    if( cardMap.find( keyword ) == cardMap.end() )
    {
        std::cerr << "Fits header card with keyword: " << keyword << " not found.\n";
    }
 
    headerIterator it = cardMap.find( keyword )->second;
 
    return *it;
}
 
void fitsHeaderGitStatus( fitsHeader &head, const std::string &repoName, const char *sha1, int modified )
{
    std::string hist = "Git status for " + repoName + ":";
    head.append( "", fitsHistoryType(), hist );
 
    hist = "   sha1=";
    hist += sha1;
    if( modified )
        hist += ", modified";
 
    head.append( "", fitsHistoryType(), hist );
}
 
} // namespace fits
} // namespace mx