Psf.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2013 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_DETECTION_Psf_h_INCLUDED
#define LSST_AFW_DETECTION_Psf_h_INCLUDED
 
#include <string>
#include <limits>
 
#include <memory>
 
#include "lsst/utils/CacheFwd.h"
#include "lsst/afw/geom/ellipses/Quadrupole.h"
#include "lsst/afw/math/Kernel.h"
#include "lsst/afw/image/Color.h"
#include "lsst/afw/table/io/Persistable.h"
#include "lsst/afw/typehandling/Storable.h"
 
namespace lsst {
namespace afw {
namespace detection {
namespace detail {
 
struct PsfCacheKey;
 
}  // namespace detail
 
class Psf : public afw::table::io::PersistableFacade<Psf>,
            public afw::typehandling::Storable {
    static lsst::geom::Point2D makeNullPoint() {
        return lsst::geom::Point2D(std::numeric_limits<double>::quiet_NaN());
    }
 
public:
    typedef math::Kernel::Pixel Pixel;  
    typedef image::Image<Pixel> Image;  
 
    enum ImageOwnerEnum {
        COPY = 0,    
        INTERNAL = 1 
    };
 
    Psf(Psf const&);
    Psf& operator=(Psf const&) = delete;
    Psf& operator=(Psf&&) = delete;
 
    Psf(Psf&&);
    ~Psf() override;
 
    virtual std::shared_ptr<Psf> clone() const = 0;
 
    std::shared_ptr<typehandling::Storable> cloneStorable() const override final { return clone(); }
 
    virtual std::shared_ptr<Psf> resized(int width, int height) const = 0;
 
    std::shared_ptr<Image> computeImage(lsst::geom::Point2D position = makeNullPoint(),
                                        image::Color color = image::Color(),
                                        ImageOwnerEnum owner = COPY) const;
 
    std::shared_ptr<Image> computeKernelImage(lsst::geom::Point2D position = makeNullPoint(),
                                              image::Color color = image::Color(),
                                              ImageOwnerEnum owner = COPY) const;
 
    double computePeak(lsst::geom::Point2D position = makeNullPoint(),
                       image::Color color = image::Color()) const;
 
    double computeApertureFlux(double radius, lsst::geom::Point2D position = makeNullPoint(),
                               image::Color color = image::Color()) const;
 
    geom::ellipses::Quadrupole computeShape(lsst::geom::Point2D position = makeNullPoint(),
                                            image::Color color = image::Color()) const;
 
    std::shared_ptr<math::Kernel const> getLocalKernel(lsst::geom::Point2D position = makeNullPoint(),
                                                       image::Color color = image::Color()) const;
 
    image::Color getAverageColor() const { return image::Color(); }
 
    virtual lsst::geom::Point2D getAveragePosition() const;
 
    lsst::geom::Box2I computeBBox(lsst::geom::Point2D position = makeNullPoint(),
                                  image::Color color = image::Color()) const;
 
    static std::shared_ptr<Image> recenterKernelImage(std::shared_ptr<Image> im,
                                                      lsst::geom::Point2D const& position,
                                                      std::string const& warpAlgorithm = "lanczos5",
                                                      unsigned int warpBuffer = 5);
 
    std::size_t getCacheCapacity() const;
 
    void setCacheCapacity(std::size_t capacity);
 
protected:
    explicit Psf(bool isFixed = false, std::size_t capacity = 100);
 
private:
 
    virtual std::shared_ptr<Image> doComputeImage(lsst::geom::Point2D const& position,
                                                  image::Color const& color) const;
    virtual std::shared_ptr<Image> doComputeKernelImage(lsst::geom::Point2D const& position,
                                                        image::Color const& color) const = 0;
    virtual double doComputeApertureFlux(double radius, lsst::geom::Point2D const& position,
                                         image::Color const& color) const = 0;
    virtual geom::ellipses::Quadrupole doComputeShape(lsst::geom::Point2D const& position,
                                                      image::Color const& color) const = 0;
    virtual lsst::geom::Box2I doComputeBBox(lsst::geom::Point2D const& position,
                                            image::Color const& color) const = 0;
 
    bool const _isFixed;
    using PsfCache = utils::Cache<detail::PsfCacheKey, std::shared_ptr<Image>>;
    std::unique_ptr<PsfCache> _imageCache;
    std::unique_ptr<PsfCache> _kernelImageCache;
};
}  // namespace detection
}  // namespace afw
}  // namespace lsst
 
#endif  // !LSST_AFW_DETECTION_Psf_h_INCLUDED