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

Asseses the quality of a candidate given a spatial kernel and background model. More...

#include <AssessSpatialKernelVisitor.h>

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

Public Types
typedef std::shared_ptr< AssessSpatialKernelVisitor< PixelT > >	Ptr

Public Member Functions
	AssessSpatialKernelVisitor (std::shared_ptr< lsst::afw::math::LinearCombinationKernel > spatialKernel, lsst::afw::math::Kernel::SpatialFunctionPtr spatialBackground, lsst::daf::base::PropertySet const &ps)
virtual	~AssessSpatialKernelVisitor ()
void	reset ()
int	getNGood ()
int	getNRejected ()
int	getNProcessed ()
void	processCandidate (lsst::afw::math::SpatialCellCandidate *candidate)

Detailed Description

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

Asseses the quality of a candidate given a spatial kernel and background model.

detail::AssessSpatialKernelVisitor<PixelT> spatialKernelAssessor(spatialKernel,
                                                                 spatialBackground,
                                                                 ps);
spatialKernelAssessor.reset();
kernelCells.visitCandidates(&spatialKernelAssessor, nStarPerCell);
nRejected = spatialKernelAssessor.getNRejected();

Note

Evaluates the spatial kernel and spatial background at the location of each candidate, and computes the resulting difference image. Sets candidate as afwMath::SpatialCellCandidate::GOOD/BAD if requested by the PropertySet configuration.

Definition at line 26 of file AssessSpatialKernelVisitor.h.

Member Typedef Documentation

Ptr

template<typename PixelT >

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

Definition at line 29 of file AssessSpatialKernelVisitor.h.

Constructor & Destructor Documentation

AssessSpatialKernelVisitor()

template<typename PixelT >

lsst::ip::diffim::detail::AssessSpatialKernelVisitor< PixelT >::AssessSpatialKernelVisitor	(	std::shared_ptr< lsst::afw::math::LinearCombinationKernel >	spatialKernel,
		lsst::afw::math::Kernel::SpatialFunctionPtr	spatialBackground,
		lsst::daf::base::PropertySet const &	ps )

Parameters

spatialKernel	Spatially varying kernel
spatialBackground	Spatially varying background
ps	PropertySet config

Definition at line 54 of file AssessSpatialKernelVisitor.cc.

          :
        afwMath::CandidateVisitor(),
        _spatialKernel(spatialKernel),
        _spatialBackground(spatialBackground),
        _ps(ps.deepCopy()),
        _imstats(ImageStatistics<PixelT>(ps)),
        _nGood(0),
        _nRejected(0),
        _nProcessed(0),
        _useCoreStats(ps.getAsBool("useCoreStats")),
        _coreRadius(ps.getAsInt("candidateCoreRadius"))
    {};

~AssessSpatialKernelVisitor()

template<typename PixelT >

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

inlinevirtual

Definition at line 36 of file AssessSpatialKernelVisitor.h.

{};

Member Function Documentation

getNGood()

template<typename PixelT >

int lsst::ip::diffim::detail::AssessSpatialKernelVisitor< PixelT >::getNGood ( )

inline

Definition at line 40 of file AssessSpatialKernelVisitor.h.

{return _nGood;}

getNProcessed()

template<typename PixelT >

int lsst::ip::diffim::detail::AssessSpatialKernelVisitor< PixelT >::getNProcessed ( )

inline

Definition at line 42 of file AssessSpatialKernelVisitor.h.

{return _nProcessed;}

getNRejected()

template<typename PixelT >

int lsst::ip::diffim::detail::AssessSpatialKernelVisitor< PixelT >::getNRejected ( )

inline

Definition at line 41 of file AssessSpatialKernelVisitor.h.

{return _nRejected;}

processCandidate()

template<typename PixelT >

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

virtual

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

Definition at line 72 of file AssessSpatialKernelVisitor.cc.

          {
 
        KernelCandidate<PixelT> *kCandidate = dynamic_cast<KernelCandidate<PixelT> *>(candidate);
        if (kCandidate == NULL) {
            throw LSST_EXCEPT(pexExcept::LogicError,
                              "Failed to cast SpatialCellCandidate to KernelCandidate");
        }
        if (!(kCandidate->isInitialized())) {
            kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
            LOGL_DEBUG("TRACE2.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                       "Cannot process candidate %d, continuing", kCandidate->getId());
            return;
        }
 
        LOGL_DEBUG("TRACE1.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                   "Processing candidate %d", kCandidate->getId());
 
        /*
           Note - this is a hack until the Kernel API is upgraded by the
           Davis crew.  I need a "local" version of the spatially varying
           Kernel
        */
        afwImage::Image<double> kImage(_spatialKernel->getDimensions());
        double kSum = _spatialKernel->computeImage(kImage, false,
                                                   kCandidate->getXCenter(), kCandidate->getYCenter());
        std::shared_ptr<afwMath::Kernel>
            kernelPtr(new afwMath::FixedKernel(kImage));
        /* </hack> */
 
        double background = (*_spatialBackground)(kCandidate->getXCenter(), kCandidate->getYCenter());
 
        MaskedImageT diffim = kCandidate->getDifferenceImage(kernelPtr, background);
 
        if (DEBUG_IMAGES) {
            kImage.writeFits(str(boost::format("askv_k%d.fits") % kCandidate->getId()));
            diffim.writeFits(str(boost::format("askv_d%d.fits") % kCandidate->getId()));
        }
 
        /* Official resids */
        try {
            if (_useCoreStats)
                _imstats.apply(diffim, _coreRadius);
            else
                _imstats.apply(diffim);
        } catch (pexExcept::Exception& e) {
            LOGL_DEBUG("TRACE2.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                       "Unable to calculate imstats for Candidate %d", kCandidate->getId());
            kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
            return;
        }
 
        _nProcessed += 1;
 
        LOGL_DEBUG("TRACE4.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                   "Chi2 = %.3f", _imstats.getVariance());
        LOGL_DEBUG("TRACE4.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                   "X = %.2f Y = %.2f",
                   kCandidate->getXCenter(),
                   kCandidate->getYCenter());
        LOGL_DEBUG("TRACE4.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                   "Kernel Sum = %.3f", kSum);
        LOGL_DEBUG("TRACE4.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                   "Background = %.3f", background);
        LOGL_DEBUG("TRACE2.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                   "Candidate %d resids = %.3f +/- %.3f sigma (%d pix)",
                   kCandidate->getId(),
                   _imstats.getMean(),
                   _imstats.getRms(),
                   _imstats.getNpix());
 
        bool meanIsNan = std::isnan(_imstats.getMean());
        bool rmsIsNan  = std::isnan(_imstats.getRms());
        if (meanIsNan || rmsIsNan) {
            kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
            LOGL_DEBUG("TRACE3.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                       "Rejecting candidate %d, encountered NaN",
                       kCandidate->getId());
            _nRejected += 1;
            return;
        }
 
        if (_ps->getAsBool("spatialKernelClipping")) {
            if (fabs(_imstats.getMean()) > _ps->getAsDouble("candidateResidualMeanMax")) {
                kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
                LOGL_DEBUG("TRACE3.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                           "Rejecting candidate %d; bad mean residual : |%.3f| > %.3f",
                           kCandidate->getId(),
                           _imstats.getMean(),
                           _ps->getAsDouble("candidateResidualMeanMax"));
                _nRejected += 1;
            }
            else if (_imstats.getRms() > _ps->getAsDouble("candidateResidualStdMax")) {
                kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
                LOGL_DEBUG("TRACE3.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                           "Rejecting candidate %d; bad residual rms : %.3f > %.3f",
                           kCandidate->getId(),
                           _imstats.getRms(),
                           _ps->getAsDouble("candidateResidualStdMax"));
                _nRejected += 1;
            }
            else {
                kCandidate->setStatus(afwMath::SpatialCellCandidate::GOOD);
                LOGL_DEBUG("TRACE3.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                           "Spatial kernel OK");
                _nGood += 1;
            }
        }
        else {
            kCandidate->setStatus(afwMath::SpatialCellCandidate::GOOD);
            LOGL_DEBUG("TRACE5.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                       "Sigma clipping not enabled");
            _nGood += 1;
        }
 
        /* Core resids for debugging */
        if (!(_useCoreStats)) {
            try {
                _imstats.apply(diffim, _coreRadius);
            } catch (pexExcept::Exception& e) {
                LOGL_DEBUG("TRACE2.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                           "Unable to calculate core imstats for Candidate %d",
                           kCandidate->getId());
                kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
                return;
            }
            LOGL_DEBUG("TRACE3.ip.diffim.AssessSpatialKernelVisitor.processCandidate",
                       "Candidate %d core resids = %.3f +/- %.3f sigma (%d pix)",
                       kCandidate->getId(),
                       _imstats.getMean(),
                       _imstats.getRms(),
                       _imstats.getNpix());
        }
    }

reset()

template<typename PixelT >

void lsst::ip::diffim::detail::AssessSpatialKernelVisitor< PixelT >::reset ( )

inlinevirtual

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

Definition at line 38 of file AssessSpatialKernelVisitor.h.

{_nGood = 0; _nRejected = 0; _nProcessed = 0;}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/ip_diffim/g180d380827+a53a32eff8/include/lsst/ip/diffim/AssessSpatialKernelVisitor.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/ip_diffim/g180d380827+a53a32eff8/src/AssessSpatialKernelVisitor.cc