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"
#include "lsst/geom/Extent.h"
#include "lsst/geom/SpherePoint.h"

namespace lsst {
namespace afw {
namespace image {

template <typename ImageT, typename MaskT = lsst::afw::image::MaskPixel,
          typename VarianceT = lsst::afw::image::VariancePixel>
class Exposure {
public:
    typedef MaskedImage<ImageT, MaskT, VarianceT> MaskedImageT;

    // Class Constructors and Destructor
    explicit Exposure(unsigned int width, unsigned int height,
                      std::shared_ptr<geom::SkyWcs const> wcs = std::shared_ptr<geom::SkyWcs const>());

    explicit Exposure(lsst::geom::Extent2I const& dimensions = lsst::geom::Extent2I(),
                      std::shared_ptr<geom::SkyWcs const> wcs = std::shared_ptr<geom::SkyWcs const>());

    explicit Exposure(lsst::geom::Box2I const& bbox,
                      std::shared_ptr<geom::SkyWcs const> wcs = std::shared_ptr<geom::SkyWcs const>());

    explicit Exposure(MaskedImageT& maskedImage,
                      std::shared_ptr<geom::SkyWcs const> wcs = std::shared_ptr<geom::SkyWcs const>());

    explicit Exposure(MaskedImageT& maskedImage, std::shared_ptr<ExposureInfo> info);

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

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

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

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

    Exposure(Exposure const& src, lsst::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                                      
             )
            : _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");
        }
    }

    Exposure& operator=(Exposure const&);
    Exposure& operator=(Exposure&&);

    Exposure subset(lsst::geom::Box2I const& bbox, ImageOrigin origin = PARENT) const {
        return Exposure(*this, bbox, origin, false);
    }

    Exposure operator[](lsst::geom::Box2I const& bbox) const { return subset(bbox); }

    virtual ~Exposure();

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

    std::shared_ptr<geom::SkyWcs const> getWcs() const { return _info->getWcs(); }

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

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

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

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

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

    // Set Members
    void setMaskedImage(MaskedImageT& maskedImage);
    void setWcs(std::shared_ptr<geom::SkyWcs> wcs) { _info->setWcs(wcs); }
    void setDetector(std::shared_ptr<lsst::afw::cameraGeom::Detector const> detector) {
        _info->setDetector(detector);
    }
    void setFilter(Filter const& filter) { _info->setFilter(filter); }

    void setPhotoCalib(std::shared_ptr<PhotoCalib const> photoCalib) { _info->setPhotoCalib(photoCalib); }
    std::shared_ptr<PhotoCalib const> getPhotoCalib() const { return _info->getPhotoCalib(); }

    void setPsf(std::shared_ptr<lsst::afw::detection::Psf const> psf) { _info->setPsf(psf); }

    std::shared_ptr<lsst::afw::detection::Psf const> getPsf() const { return _info->getPsf(); }

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

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

    std::shared_ptr<ExposureInfo> getInfo() { return _info; }

    std::shared_ptr<ExposureInfo const> getInfo() const { return _info; }

    void setInfo(std::shared_ptr<ExposureInfo> exposureInfo) { _info = exposureInfo; }

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

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

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

    void writeFits(std::string const& fileName, fits::ImageWriteOptions const& imageOptions,
                   fits::ImageWriteOptions const& maskOptions,
                   fits::ImageWriteOptions const& varianceOptions) const;

    void writeFits(fits::MemFileManager& manager, fits::ImageWriteOptions const& imageOptions,
                   fits::ImageWriteOptions const& maskOptions,
                   fits::ImageWriteOptions const& varianceOptions) const;

    void writeFits(fits::Fits& fitsfile, fits::ImageWriteOptions const& imageOptions,
                   fits::ImageWriteOptions const& maskOptions,
                   fits::ImageWriteOptions const& varianceOptions) 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);
    }

    Exposure getCutout(lsst::geom::SpherePoint const& center, lsst::geom::Extent2I const& size) const;

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

    MaskedImageT _maskedImage;
    std::shared_ptr<ExposureInfo> _info;
};

template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
std::shared_ptr<Exposure<ImagePixelT, MaskPixelT, VariancePixelT>> makeExposure(
        MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>& mimage,  
        std::shared_ptr<geom::SkyWcs const> wcs =
                std::shared_ptr<geom::SkyWcs const>()  
) {
    return typename std::shared_ptr<Exposure<ImagePixelT, MaskPixelT, VariancePixelT>>(
            new Exposure<ImagePixelT, MaskPixelT, VariancePixelT>(mimage, wcs));
}
}  // namespace image
}  // namespace afw
}  // namespace lsst

#endif  // LSST_AFW_IMAGE_EXPOSURE_H