FitsReader.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_IO_FitsReader_h_INCLUDED
#define AFW_TABLE_IO_FitsReader_h_INCLUDED
 
#include <type_traits>
 
#include "lsst/afw/fits.h"
#include "lsst/afw/table/Schema.h"
#include "lsst/afw/table/io/InputArchive.h"
#include "lsst/afw/table/io/FitsSchemaInputMapper.h"
#include "lsst/afw/table/BaseRecord.h"
#include "lsst/afw/table/BaseTable.h"
 
namespace lsst {
namespace afw {
namespace table {
namespace io {

class FitsReader {
public:
    explicit FitsReader(std::string const& persistedClassName);
 
    FitsReader(FitsReader const&) = default;
    FitsReader(FitsReader&&) = default;
    FitsReader& operator=(FitsReader const&) = default;
    FitsReader& operator=(FitsReader&&) = default;

    template <typename ContainerT>
    static ContainerT apply(afw::fits::Fits& fits, int ioFlags,
                            std::shared_ptr<InputArchive> archive = std::shared_ptr<InputArchive>()) {
        std::shared_ptr<daf::base::PropertyList> metadata = std::make_shared<daf::base::PropertyList>();
        fits.readMetadata(*metadata, true);
        FitsReader const* reader = _lookupFitsReader(*metadata);
        FitsSchemaInputMapper mapper(*metadata, true);
        reader->_setupArchive(fits, mapper, archive, ioFlags);
        std::shared_ptr<BaseTable> table = reader->makeTable(mapper, metadata, ioFlags, true);
        ContainerT container(std::dynamic_pointer_cast<typename ContainerT::Table>(table));
        if (!container.getTable()) {
            throw LSST_EXCEPT(pex::exceptions::RuntimeError, "Invalid table class for catalog.");
        }
        std::size_t nRows = fits.countRows();
        container.reserve(nRows);
        for (std::size_t row = 0; row < nRows; ++row) {
            mapper.readRecord(
                    // We need to be able to support reading Catalog<T const>, since it shares the same
                    // template
                    // as Catalog<T> (which invokes this method in readFits).
                    const_cast<typename std::remove_const<typename ContainerT::Record>::type&>(
                            *container.addNew()),
                    fits, row);
        }
        return container;
    }
    static ContainerT apply(afw::fits::Fits& fits, int ioFlags, {…}

    template <typename ContainerT, typename SourceT>
    static ContainerT apply(SourceT& source, int hdu, int ioFlags,
                            std::shared_ptr<InputArchive> archive = std::shared_ptr<InputArchive>()) {
        afw::fits::Fits fits(source, "r", afw::fits::Fits::AUTO_CLOSE | afw::fits::Fits::AUTO_CHECK);
        fits.setHdu(hdu);
        return apply<ContainerT>(fits, ioFlags, archive);
    }
    static ContainerT apply(SourceT& source, int hdu, int ioFlags, {…}

    virtual std::shared_ptr<BaseTable> makeTable(FitsSchemaInputMapper& mapper,
                                                 std::shared_ptr<daf::base::PropertyList> metadata,
                                                 int ioFlags, bool stripMetadata) const;

    virtual bool usesArchive(int ioFlags) const { return false; }
 
    virtual ~FitsReader() = default;
 
private:
    static FitsReader const* _lookupFitsReader(daf::base::PropertyList const& metadata);
 
    void _setupArchive(afw::fits::Fits& fits, FitsSchemaInputMapper& mapper,
                       std::shared_ptr<InputArchive> archive, int ioFlags) const;
};
class FitsReader {…};
}  // namespace io
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_IO_FitsReader_h_INCLUDED