Exposure.h

Go to the documentation of this file.

// -*- LSST-C++ -*- // fixed format comment for emacs

/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program 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.
 *
 * This program 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 LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */

#ifndef LSST_AFW_IMAGE_EXPOSURE_H
#define LSST_AFW_IMAGE_EXPOSURE_H

#include <memory>

#include "lsst/base.h"
#include "lsst/daf/base.h"
#include "lsst/afw/image/MaskedImage.h"
#include "lsst/afw/image/ExposureInfo.h"

namespace lsst { namespace afw {

namespace formatters {
    template<typename ImageT, typename MaskT, typename VarianceT> class ExposureFormatter;
}

namespace image {

template<typename ImageT, typename MaskT=lsst::afw::image::MaskPixel,
         typename VarianceT=lsst::afw::image::VariancePixel>
class Exposure : public lsst::daf::base::Persistable,
                 public lsst::daf::base::Citizen {
public:
    typedef MaskedImage<ImageT, MaskT, VarianceT> MaskedImageT;
    typedef std::shared_ptr<Exposure> Ptr;
    typedef std::shared_ptr<Exposure const> ConstPtr;

    // Class Constructors and Destructor
    explicit Exposure(
        unsigned int width, unsigned int height,
        CONST_PTR(Wcs) wcs = CONST_PTR(Wcs)()
    );

    explicit Exposure(
        lsst::afw::geom::Extent2I const & dimensions=lsst::afw::geom::Extent2I(),
        CONST_PTR(Wcs) wcs = CONST_PTR(Wcs)()
    );

    explicit Exposure(
        lsst::afw::geom::Box2I const & bbox,
        CONST_PTR(Wcs) wcs = CONST_PTR(Wcs)()
    );

    explicit Exposure(MaskedImageT & maskedImage,
                      CONST_PTR(Wcs) wcs = CONST_PTR(Wcs)());

    explicit Exposure(
        MaskedImageT & maskedImage,
        PTR(ExposureInfo) info
    );

    explicit Exposure(
        std::string const & fileName, geom::Box2I const& bbox=geom::Box2I(),
        ImageOrigin origin=PARENT, bool conformMasks=false
    );

    explicit Exposure(
        fits::MemFileManager & manager, geom::Box2I const & bbox=geom::Box2I(),
        ImageOrigin origin=PARENT, bool conformMasks=false
    );

    explicit Exposure(
        fits::Fits & fitsfile, geom::Box2I const & bbox=geom::Box2I(),
        ImageOrigin origin=PARENT, bool conformMasks=false
    );

    Exposure(
        Exposure const &src,
        bool const deep=false
    );

    Exposure(
        Exposure const &src,
        lsst::afw::geom::Box2I const& bbox,
        ImageOrigin const origin=PARENT,
        bool const deep=false
    );

    template<typename OtherPixelT>
    Exposure(Exposure<OtherPixelT, MaskT, VarianceT> const& rhs, 
             const bool deep        
    ) :
        lsst::daf::base::Citizen(typeid(this)),
        _maskedImage(rhs.getMaskedImage(), deep),
        _info(new ExposureInfo(*rhs.getInfo(), deep))
    {
        if (not deep) {
            throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                              "Exposure's converting copy constructor must make a deep copy");
        }
    }

    virtual ~Exposure();

    // Get Members
    MaskedImageT getMaskedImage() { return _maskedImage; }
    MaskedImageT getMaskedImage() const { return _maskedImage; }

    CONST_PTR(Wcs) getWcs() const { return _info->getWcs(); }
    PTR(Wcs) getWcs() { return _info->getWcs(); }

    CONST_PTR(lsst::afw::cameraGeom::Detector) getDetector() const { return _info->getDetector(); }
    Filter getFilter() const { return _info->getFilter(); }
    lsst::daf::base::PropertySet::Ptr getMetadata() const { return _info->getMetadata(); }
    void setMetadata(lsst::daf::base::PropertySet::Ptr metadata) { _info->setMetadata(metadata); }

    int getWidth() const { return _maskedImage.getWidth(); }
    int getHeight() const { return _maskedImage.getHeight(); }
    geom::Extent2I getDimensions() const { return _maskedImage.getDimensions(); }

    int getX0() const { return _maskedImage.getX0(); }
    int getY0() const { return _maskedImage.getY0(); }

    geom::Point2I getXY0() const { return _maskedImage.getXY0(); }

    geom::Box2I getBBox(ImageOrigin const origin=PARENT) const {
        return _maskedImage.getBBox(origin);
    }
    void setXY0(geom::Point2I const & origin);

    // Set Members
    void setMaskedImage(MaskedImageT &maskedImage);
    void setWcs(PTR(Wcs) wcs) { _info->setWcs(wcs); }
    void setDetector(CONST_PTR(lsst::afw::cameraGeom::Detector) detector) { _info->setDetector(detector); }
    void setFilter(Filter const& filter) { _info->setFilter(filter); }
    void setCalib(PTR(Calib) calib) { _info->setCalib(calib); }
    PTR(Calib) getCalib() { return _info->getCalib(); }
    CONST_PTR(Calib) getCalib() const { return _info->getCalib(); }
    void setPsf(CONST_PTR(lsst::afw::detection::Psf) psf) { _info->setPsf(psf); }

    PTR(lsst::afw::detection::Psf) getPsf() { return _info->getPsf(); }
    CONST_PTR(lsst::afw::detection::Psf) getPsf() const { return _info->getPsf(); }

    bool hasPsf() const { return _info->hasPsf(); }

    bool hasWcs() const { return _info->hasWcs(); }

    PTR(ExposureInfo) getInfo() { return _info; }

    CONST_PTR(ExposureInfo) getInfo() const { return _info; }

    void setInfo(PTR(ExposureInfo) exposureInfo) { _info = exposureInfo; }

    void writeFits(std::string const & fileName) const;

    void writeFits(fits::MemFileManager & manager) const;

    void writeFits(fits::Fits & fitsfile) const;

    static Exposure readFits(std::string const & filename) {
        return Exposure<ImageT, MaskT, VarianceT>(filename);
    }

    static Exposure readFits(fits::MemFileManager & manager) {
        return Exposure<ImageT, MaskT, VarianceT>(manager);
    }

private:
    LSST_PERSIST_FORMATTER(lsst::afw::formatters::ExposureFormatter<ImageT, MaskT, VarianceT>)

    void _readFits(
        fits::Fits & fitsfile, geom::Box2I const & bbox,
        ImageOrigin origin, bool conformMasks
    );

    MaskedImageT _maskedImage;
    PTR(ExposureInfo) _info;
};

template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
typename Exposure<ImagePixelT, MaskPixelT, VariancePixelT>::Ptr makeExposure(
    MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT> & mimage, 
    CONST_PTR(Wcs) wcs = CONST_PTR(Wcs)() 
) {
    return typename Exposure<ImagePixelT, MaskPixelT, VariancePixelT>::Ptr(
        new Exposure<ImagePixelT, MaskPixelT, VariancePixelT>(mimage, wcs));
}

}}} // lsst::afw::image

#endif // LSST_AFW_IMAGE_EXPOSURE_H