KernelCandidate.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef LSST_IP_DIFFIM_KERNELCANDIDATE_H
#define LSST_IP_DIFFIM_KERNELCANDIDATE_H

#include <memory>
#include "Eigen/Core"

#include "lsst/afw/math.h"
#include "lsst/afw/image.h"
#include "lsst/ip/diffim/KernelSolution.h"
#include "lsst/afw/table/Source.h"
#include "lsst/daf/base.h"

namespace lsst {
namespace ip {
namespace diffim {


    template <typename _PixelT>
    class KernelCandidate : public afw::math::SpatialCellImageCandidate {
    public:
        typedef afw::image::Image<afw::math::Kernel::Pixel> ImageT;
        typedef _PixelT PixelT;         // _after_ afw::math::Kernel::Pixel
    public:
        typedef std::shared_ptr<KernelCandidate> Ptr;
        typedef std::shared_ptr<afw::image::MaskedImage<PixelT> > MaskedImagePtr;
        typedef std::shared_ptr<afw::image::Image<afw::image::VariancePixel> > VariancePtr;
        typedef std::shared_ptr<afw::table::SourceRecord> SourcePtr;

        enum CandidateSwitch {
            ORIG    = 0,
            PCA     = 1,
            RECENT  = 2
        };

        KernelCandidate(float const xCenter,
                        float const yCenter,
                        MaskedImagePtr const& templateMaskedImage,
                        MaskedImagePtr const& scienceMaskedImage,
                        daf::base::PropertySet const& ps);

        KernelCandidate(SourcePtr const& source,
                        MaskedImagePtr const& templateMaskedImage,
                        MaskedImagePtr const& scienceMaskedImage,
                        daf::base::PropertySet const& ps);
        virtual ~KernelCandidate() {};

        double getCandidateRating() const { return _coreFlux; }
        SourcePtr getSource() const { return _source; }
        MaskedImagePtr getTemplateMaskedImage() {return _templateMaskedImage;}
        MaskedImagePtr getScienceMaskedImage() {return _scienceMaskedImage;}

        std::shared_ptr<afw::math::Kernel> getKernel(CandidateSwitch cand) const;
        double getBackground(CandidateSwitch cand) const;
        double getKsum(CandidateSwitch cand) const;
        PTR(ImageT) getKernelImage(CandidateSwitch cand) const;
        CONST_PTR(ImageT) getImage() const; // For SpatialCellImageCandidate
        std::shared_ptr<StaticKernelSolution<PixelT> > getKernelSolution(CandidateSwitch cand) const;

        afw::image::MaskedImage<PixelT> getDifferenceImage(CandidateSwitch cand);

        afw::image::MaskedImage<PixelT> getDifferenceImage(
            std::shared_ptr<afw::math::Kernel> kernel,
            double background
            );

        bool isInitialized() const {return _isInitialized;}


        /*
         * @note This method uses an estimate of the variance which is the
         * straight difference of the 2 images.  If requested in the PropertySet
         * ("iterateSingleKernel"), the kernel will be rebuilt using the
         * variance of the difference image resulting from this first
         * approximate step.  This is particularly useful when convolving a
         * single-depth science image; the variance (and thus resulting kernel)
         * generally converges after 1 iteration.  If
         * "constantVarianceWeighting" is requested in the PropertySet, no iterations
         * will be performed even if requested.
         */

        void build(
            afw::math::KernelList const& basisList
            );
        void build(
            afw::math::KernelList const& basisList,
            Eigen::MatrixXd const& hMat
            );

    private:
        MaskedImagePtr _templateMaskedImage;                
        MaskedImagePtr _scienceMaskedImage;                 
        VariancePtr _varianceEstimate;                      
        daf::base::PropertySet::Ptr _ps;                    
        SourcePtr _source;
        double _coreFlux;                                   
        bool _isInitialized;                                
        bool _useRegularization;                            
        bool _fitForBackground;

        /* best single raw kernel */
        std::shared_ptr<StaticKernelSolution<PixelT> > _kernelSolutionOrig; 

        /* with Pca basis */
        std::shared_ptr<StaticKernelSolution<PixelT> > _kernelSolutionPca;  

        void _buildKernelSolution(afw::math::KernelList const& basisList,
                                  Eigen::MatrixXd const& hMat);
    };


    template <typename PixelT>
    std::shared_ptr<KernelCandidate<PixelT> >
    makeKernelCandidate(float const xCenter,
                        float const yCenter,
                        std::shared_ptr<afw::image::MaskedImage<PixelT> > const& templateMaskedImage,
                        std::shared_ptr<afw::image::MaskedImage<PixelT> > const& scienceMaskedImage,
                        daf::base::PropertySet const& ps){

        return std::shared_ptr<KernelCandidate<PixelT>>(new KernelCandidate<PixelT>(xCenter, yCenter,
                                                                                 templateMaskedImage,
                                                                                 scienceMaskedImage,
                                                                                 ps));
    }

    template <typename PixelT>
    std::shared_ptr<KernelCandidate<PixelT> >
    makeKernelCandidate(std::shared_ptr<afw::table::SourceRecord> const & source,
                        std::shared_ptr<afw::image::MaskedImage<PixelT> > const& templateMaskedImage,
                        std::shared_ptr<afw::image::MaskedImage<PixelT> > const& scienceMaskedImage,
                        daf::base::PropertySet const& ps){

        return std::shared_ptr<KernelCandidate<PixelT>>(new KernelCandidate<PixelT>(source,
                                                                                    templateMaskedImage,
                                                                                    scienceMaskedImage,
                                                                                    ps));
    }


}}} // end of namespace lsst::ip::diffim

#endif