lsst::ip::diffim::detail::KernelPcaVisitor< PixelT > Class Template Reference

A class to run a PCA on all candidate kernels (represented as Images). More...

#include <KernelPca.h>

Inheritance diagram for lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >:

Public Types
typedef lsst::afw::image::Image< lsst::afw::math::Kernel::Pixel >	ImageT
typedef std::shared_ptr< KernelPcaVisitor< PixelT > >	Ptr

Public Member Functions
	KernelPcaVisitor (std::shared_ptr< KernelPca< ImageT > > imagePca)
virtual	~KernelPcaVisitor ()
lsst::afw::math::KernelList	getEigenKernels ()
void	processCandidate (lsst::afw::math::SpatialCellCandidate *candidate)
void	subtractMean ()
std::shared_ptr< ImageT >	returnMean ()
virtual void	reset ()

Detailed Description

template<typename PixelT>
class lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >

A class to run a PCA on all candidate kernels (represented as Images).

Note

Templated on the pixel types of the MaskedImages it will be visiting (typically float).

Works in concert with a afwMath::SpatialCellSet and ip::Diffim KernelPca to create a Karhunen-Loeve basis from all the good KernelCandidates. This class adds the extra functionality to subtract off the mean kernel from all entries, which makes the resulting basis more compact. The user needs to manually add this mean image into the resulting basis list after imagePca.analyze() is called.

KernelPca (and base class afwImage::ImagePca) weight objects of different brightness differently. However we don't necessarily want images with larger kernel sums to have more weight. Each kernel should have constant weight in the Pca. For simplicity we scale them to have the same kernel sum, 1.0, and send to ImagePca that the flux (weight) is 1.0.

Definition at line 40 of file KernelPca.h.

Member Typedef Documentation

ImageT

template<typename PixelT >

typedef lsst::afw::image::Image<lsst::afw::math::Kernel::Pixel> lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >::ImageT

Definition at line 42 of file KernelPca.h.

Ptr

template<typename PixelT >

typedef std::shared_ptr<KernelPcaVisitor<PixelT> > lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >::Ptr

Definition at line 43 of file KernelPca.h.

Constructor & Destructor Documentation

KernelPcaVisitor()

template<typename PixelT >

lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >::KernelPcaVisitor

(

std::shared_ptr< KernelPca< ImageT > >

imagePca

)

Parameters

imagePca

Set of Images to initialise

Definition at line 56 of file KernelPca.cc.

          :
        afwMath::CandidateVisitor(),
        _imagePca(imagePca),
        _mean()
    {};

~KernelPcaVisitor()

template<typename PixelT >

virtual lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >::~KernelPcaVisitor ( )

inlinevirtual

Definition at line 46 of file KernelPca.h.

{};

Member Function Documentation

getEigenKernels()

template<typename PixelT >

lsst::afw::math::KernelList lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >::getEigenKernels

Definition at line 65 of file KernelPca.cc.

                                                                    {
        afwMath::KernelList kernelList;
 
        std::vector<std::shared_ptr<ImageT>> eigenImages = _imagePca->getEigenImages();
        int ncomp = eigenImages.size();
 
        if (_mean) {
            kernelList.push_back(std::shared_ptr<afwMath::Kernel>(
                                     new afwMath::FixedKernel(
                                         afwImage::Image<afwMath::Kernel::Pixel>
                                         (*_mean, true))));
        }
        for (int i = 0; i < ncomp; i++) {
            afwImage::Image<afwMath::Kernel::Pixel> img =
                afwImage::Image<afwMath::Kernel::Pixel>(*eigenImages[i], true);
            kernelList.push_back(std::shared_ptr<afwMath::Kernel>(
                                     new afwMath::FixedKernel(img)
                                     ));
        }
 
        return kernelList;
    }

processCandidate()

template<typename PixelT >

void lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >::processCandidate ( lsst::afw::math::SpatialCellCandidate *  candidate )

virtual

Reimplemented from lsst::afw::math::CandidateVisitor.

Definition at line 89 of file KernelPca.cc.

                                                                                              {
 
        KernelCandidate<PixelT> *kCandidate = dynamic_cast<KernelCandidate<PixelT> *>(candidate);
        if (kCandidate == NULL) {
            throw LSST_EXCEPT(pexExcept::LogicError,
                              "Failed to cast SpatialCellCandidate to KernelCandidate");
        }
        LOGL_DEBUG("TRACE5.ip.diffim.SetPcaImageVisitor.processCandidate",
                   "Processing candidate %d", kCandidate->getId());
 
        try {
            /* Normalize to unit sum */
            std::shared_ptr<ImageT> kImage = kCandidate->getKernelSolution(
                KernelCandidate<PixelT>::ORIG)->makeKernelImage();
            *kImage           /= kCandidate->getKernelSolution(
                KernelCandidate<PixelT>::ORIG)->getKsum();
            /* Tell imagePca they have the same weighting in the Pca */
            _imagePca->addImage(kImage, 1.0);
        } catch(pexExcept::Exception &e) {
            return;
        }
    }

reset()

virtual void lsst::afw::math::CandidateVisitor::reset ( )

inlinevirtualinherited

Reimplemented in lsst::meas::algorithms::evalChi2Visitor< PixelT >, lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >, and lsst::ip::diffim::detail::AssessSpatialKernelVisitor< PixelT >.

Definition at line 63 of file SpatialCell.h.

{}

returnMean()

template<typename PixelT >

std::shared_ptr<ImageT> lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >::returnMean ( )

inline

Definition at line 51 of file KernelPca.h.

{return _mean;}

subtractMean()

template<typename PixelT >

void lsst::ip::diffim::detail::KernelPcaVisitor< PixelT >::subtractMean

Definition at line 113 of file KernelPca.cc.

                                                {
        /*
           If we don't subtract off the mean before we do the Pca, the
           subsequent terms carry less of the power than if you do subtract
           off the mean.  Explicit example:
 
           With mean subtraction:
             DEBUG: Eigenvalue 0 : 0.010953 (0.373870 %)
             DEBUG: Eigenvalue 1 : 0.007927 (0.270604 %)
             DEBUG: Eigenvalue 2 : 0.001393 (0.047542 %)
             DEBUG: Eigenvalue 3 : 0.001092 (0.037261 %)
             DEBUG: Eigenvalue 4 : 0.000829 (0.028283 %)
 
           Without mean subtraction:
             DEBUG: Eigenvalue 0 : 0.168627 (0.876046 %)
             DEBUG: Eigenvalue 1 : 0.007935 (0.041223 %)
             DEBUG: Eigenvalue 2 : 0.006049 (0.031424 %)
             DEBUG: Eigenvalue 3 : 0.001188 (0.006173 %)
             DEBUG: Eigenvalue 4 : 0.001050 (0.005452 %)
 
           After the first term above, which basically represents the mean,
           the remaining terms carry less of the power than if you do
           subtract off the mean.  (0.041223/(1-0.876046) < 0.373870).
         */
        LOGL_DEBUG("TRACE5.ip.diffim.KernelPcaVisitor.subtractMean",
                   "Subtracting mean feature before Pca");
 
        _mean = _imagePca->getMean();
        KernelPca<ImageT>::ImageList imageList = _imagePca->getImageList();
        for (typename KernelPca<ImageT>::ImageList::const_iterator ptr = imageList.begin(),
                 end = imageList.end(); ptr != end; ++ptr) {
            **ptr -= *_mean;
        }
    }

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/ip_diffim/22.0.1-24-g1ad7a390+a9625a72a8/include/lsst/ip/diffim/KernelPca.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/ip_diffim/22.0.1-24-g1ad7a390+a9625a72a8/src/KernelPca.cc