lsst::ip::diffim::KernelCandidate< _PixelT > Class Template Reference

Class stored in SpatialCells for spatial Kernel fitting. More...

#include <KernelCandidate.h>

Inheritance diagram for lsst::ip::diffim::KernelCandidate< _PixelT >:

Public Types
enum	CandidateSwitch { ORIG = 0 , PCA = 1 , RECENT = 2 }
typedef afw::image::Image< afw::math::Kernel::Pixel >	ImageT
typedef _PixelT	PixelT
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	Status { BAD = 0 , GOOD = 1 , UNKNOWN = 2 }

Public Member Functions
	KernelCandidate (float const xCenter, float const yCenter, MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage, daf::base::PropertySet const &ps)
	Constructor.
	KernelCandidate (SourcePtr const &source, MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage, daf::base::PropertySet const &ps)
	Constructor.
virtual	~KernelCandidate ()
	Destructor.
double	getCandidateRating () const
	Return Candidate rating.
SourcePtr	getSource () const
	Return the original source.
MaskedImagePtr	getTemplateMaskedImage ()
	Return pointers to the image pixels used in kernel determination.
MaskedImagePtr	getScienceMaskedImage ()
std::shared_ptr< afw::math::Kernel >	getKernel (CandidateSwitch cand) const
	Return results of kernel solution.
double	getBackground (CandidateSwitch cand) const
double	getKsum (CandidateSwitch cand) const
std::shared_ptr< ImageT >	getKernelImage (CandidateSwitch cand) const
std::shared_ptr< ImageT const >	getImage () const
std::shared_ptr< StaticKernelSolution< PixelT > >	getKernelSolution (CandidateSwitch cand) const
afw::image::MaskedImage< PixelT >	getDifferenceImage (CandidateSwitch cand)
	Calculate associated difference image using internal solutions.
afw::image::MaskedImage< PixelT >	getDifferenceImage (std::shared_ptr< afw::math::Kernel > kernel, double background)
	Calculate associated difference image using input kernel and background.
bool	isInitialized () const
void	build (afw::math::KernelList const &basisList)
	Core functionality of KernelCandidate, to build and fill a KernelSolution.
void	build (afw::math::KernelList const &basisList, Eigen::MatrixXd const &hMat)
double	getChi2 () const
	Return the candidate's chi^2.
void	setChi2 (double chi2)
	Set the candidate's chi^2.
float	getXCenter () const
	Return the object's column-centre.
float	getYCenter () const
	Return the object's row-centre.
virtual bool	instantiate ()
	Do anything needed to make this candidate usable.
virtual void	setCandidateRating (double)
	Set the candidate's rating.
int	getId () const
	Return the candidate's unique ID.
Status	getStatus () const
	Return the candidate's status.
void	setStatus (Status status)
	Set the candidate's status.
virtual bool	isBad () const
	Is this candidate unacceptable?

Static Public Member Functions
static void	setWidth (int width)
	Set the width of the image that getImage should return.
static int	getWidth ()
	Return the width of the image that getImage should return.
static void	setHeight (int height)
	Set the height of the image that getImage should return.
static int	getHeight ()
	Return the height of the image that getImage should return.

Detailed Description

template<typename _PixelT>
class lsst::ip::diffim::KernelCandidate< _PixelT >

Class stored in SpatialCells for spatial Kernel fitting.

Note

KernelCandidate is a single Kernel derived around a source. We'll assign them to sets of SpatialCells; these sets will then be used to fit a spatial model to the Kernel.

Definition at line 39 of file KernelCandidate.h.

Member Typedef Documentation

ImageT

template<typename _PixelT >

typedef afw::image::Image<afw::math::Kernel::Pixel> lsst::ip::diffim::KernelCandidate< _PixelT >::ImageT

Definition at line 41 of file KernelCandidate.h.

MaskedImagePtr

template<typename _PixelT >

typedef std::shared_ptr<afw::image::MaskedImage<PixelT> > lsst::ip::diffim::KernelCandidate< _PixelT >::MaskedImagePtr

Definition at line 45 of file KernelCandidate.h.

PixelT

template<typename _PixelT >

typedef _PixelT lsst::ip::diffim::KernelCandidate< _PixelT >::PixelT

Definition at line 42 of file KernelCandidate.h.

Ptr

template<typename _PixelT >

typedef std::shared_ptr<KernelCandidate> lsst::ip::diffim::KernelCandidate< _PixelT >::Ptr

Definition at line 44 of file KernelCandidate.h.

SourcePtr

template<typename _PixelT >

typedef std::shared_ptr<afw::table::SourceRecord> lsst::ip::diffim::KernelCandidate< _PixelT >::SourcePtr

Definition at line 47 of file KernelCandidate.h.

VariancePtr

template<typename _PixelT >

typedef std::shared_ptr<afw::image::Image<afw::image::VariancePixel> > lsst::ip::diffim::KernelCandidate< _PixelT >::VariancePtr

Definition at line 46 of file KernelCandidate.h.

Member Enumeration Documentation

CandidateSwitch

template<typename _PixelT >

enum lsst::ip::diffim::KernelCandidate::CandidateSwitch

Enumerator
ORIG
PCA
RECENT

Definition at line 49 of file KernelCandidate.h.

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

Status

enum lsst::afw::math::SpatialCellCandidate::Status

inherited

Enumerator
BAD
GOOD
UNKNOWN

Definition at line 72 of file SpatialCell.h.

{ BAD = 0, GOOD = 1, UNKNOWN = 2 };

Constructor & Destructor Documentation

KernelCandidate() [1/2]

template<typename PixelT >

lsst::ip::diffim::KernelCandidate< PixelT >::KernelCandidate	(	float const	xCenter,
		float const	yCenter,
		MaskedImagePtr const &	templateMaskedImage,
		MaskedImagePtr const &	scienceMaskedImage,
		daf::base::PropertySet const &	ps )

Constructor.

Parameters

xCenter	Col position of object
yCenter	Row position of object
templateMaskedImage	Pointer to template image
scienceMaskedImage	Pointer to science image
ps	PropertySet

Definition at line 32 of file KernelCandidate.cc.

        : lsst::afw::math::SpatialCellImageCandidate(xCenter, yCenter),
          _templateMaskedImage(templateMaskedImage),
          _scienceMaskedImage(scienceMaskedImage),
          _varianceEstimate(),
          _ps(ps.deepCopy()),
          _source(),
          _coreFlux(),
          _isInitialized(false),
          _useRegularization(false),
          _fitForBackground(ps.getAsBool("fitForBackground")),
          _kernelSolutionOrig(),
          _kernelSolutionPca() {
    /* Rank by mean core S/N in science image */
    ImageStatistics<PixelT> imstats(ps);
    int candidateCoreRadius = _ps->getAsInt("candidateCoreRadius");
    try {
        imstats.apply(*_scienceMaskedImage, candidateCoreRadius);
    } catch (pexExcept::Exception& e) {
        LOGL_DEBUG("TRACE2.ip.diffim.KernelCandidate",
                   "Unable to calculate core imstats for rating Candidate %d", this->getId());
        this->setStatus(afwMath::SpatialCellCandidate::BAD);
        return;
    }
 
    _coreFlux = imstats.getMean();
    LOGL_DEBUG("TRACE4.ip.diffim.KernelCandidate", "Candidate %d at %.2f %.2f with rating %.2f",
               this->getId(), this->getXCenter(), this->getYCenter(), _coreFlux);
}

KernelCandidate() [2/2]

template<typename PixelT >

lsst::ip::diffim::KernelCandidate< PixelT >::KernelCandidate	(	SourcePtr const &	source,
		MaskedImagePtr const &	templateMaskedImage,
		MaskedImagePtr const &	scienceMaskedImage,
		daf::base::PropertySet const &	ps )

Constructor.

Parameters

source	Pointer to a source to use in constructing the candidate
templateMaskedImage	Pointer to template image
scienceMaskedImage	Pointer to science image
ps	PropertySet

Definition at line 66 of file KernelCandidate.cc.

        : lsst::afw::math::SpatialCellImageCandidate(source->getX(), source->getY()),
          _templateMaskedImage(templateMaskedImage),
          _scienceMaskedImage(scienceMaskedImage),
          _varianceEstimate(),
          _ps(ps.deepCopy()),
          _source(source),
          _coreFlux(source->getPsfInstFlux()),
          _isInitialized(false),
          _useRegularization(false),
          _fitForBackground(ps.getAsBool("fitForBackground")),
          _kernelSolutionOrig(),
          _kernelSolutionPca() {
    LOGL_DEBUG("TRACE4.ip.diffim.KernelCandidate", "Candidate %d at %.2f %.2f with rating %.2f",
               this->getId(), this->getXCenter(), this->getYCenter(), _coreFlux);
}

~KernelCandidate()

template<typename _PixelT >

virtual lsst::ip::diffim::KernelCandidate< _PixelT >::~KernelCandidate ( )

inlinevirtual

Destructor.

Definition at line 84 of file KernelCandidate.h.

{};

Member Function Documentation

build() [1/2]

template<typename PixelT >

void lsst::ip::diffim::KernelCandidate< PixelT >::build

(

afw::math::KernelList const &

basisList

)

Core functionality of KernelCandidate, to build and fill a KernelSolution.

Note

This is an expensive step involving matrix math, and one that may be called multiple times per candidate. Use cases are:

o _isInitialized = false. This is a constructed but not initialized KernelCandidate. When build() is called, M and B are derived from the MaskedImages and the basisList. KernelCandidate owns the knowledge of how to fill this KernelSolution; the solution knows how to solve itself and how to turn that into an output kernel. This solution ends up being _kernelSolution0.

o _isInitialized = true. This is for when build() is re-called using a different basis list, e.g. one based on Pca. We need to use M and B for the spatial modeling, but do not want to override the original KernelSolution. This solution ends up as _kernelSolutionCurrent.

Build KernelSolution matrices for M x = B with regularization matrix H

Note

Modified equation is (Mt.M + lambda H) x = Mt.B with lambda a degree of freedom describing the "strength" of the regularization. The larger the value of lambda, the smoother the kernel, but the larger the residuals in the difference image.

A value of lambda = Trace(Mt.M) / Tr(H) will yield essentially equivalent power in the kernel smoothness and in the diffim quality. We scale this estimate by lambdaScaling to give more/less consideration to the smoothness of the kernel.

Definition at line 86 of file KernelCandidate.cc.

                                                                          {
    build(basisList, Eigen::MatrixXd());
}

build() [2/2]

template<typename PixelT >

void lsst::ip::diffim::KernelCandidate< PixelT >::build	(	afw::math::KernelList const &	basisList,
		Eigen::MatrixXd const &	hMat )

Definition at line 91 of file KernelCandidate.cc.

                                                               {
    /* Examine the property set for control over the variance estimate */
    afwImage::Image<afwImage::VariancePixel> var =
            afwImage::Image<afwImage::VariancePixel>(*(_scienceMaskedImage->getVariance()), true);
    /* Variance estimate comes from sum of image variances */
    var += (*(_templateMaskedImage->getVariance()));
 
    if (_ps->getAsBool("constantVarianceWeighting")) {
        /* Constant variance weighting */
        afwMath::Statistics varStats = afwMath::makeStatistics(var, afwMath::MEDIAN);
        float varValue;
        if (varStats.getValue(afwMath::MEDIAN) <= 0.0)
            varValue = 1.0;
        else
            varValue = varStats.getValue(afwMath::MEDIAN);
        LOGL_DEBUG("TRACE4.ip.diffim.KernelCandidate", "Candidate %d using constant variance of %.2f",
                   this->getId(), varValue);
        var = varValue;
    }
 
    _varianceEstimate = VariancePtr(new afwImage::Image<afwImage::VariancePixel>(var));
 
    try {
        _buildKernelSolution(basisList, hMat);
    } catch (pexExcept::Exception& e) {
        throw e;
    }
 
    if (_ps->getAsBool("iterateSingleKernel") && (!(_ps->getAsBool("constantVarianceWeighting")))) {
        afwImage::MaskedImage<PixelT> diffim = getDifferenceImage(KernelCandidate::RECENT);
        _varianceEstimate = diffim.getVariance();
 
        try {
            _buildKernelSolution(basisList, hMat);
        } catch (pexExcept::Exception& e) {
            throw e;
        }
    }
 
    _isInitialized = true;
}

getBackground()

template<typename PixelT >

double lsst::ip::diffim::KernelCandidate< PixelT >::getBackground

(

CandidateSwitch

cand

)

const

Definition at line 247 of file KernelCandidate.cc.

                                                                        {
    switch (cand) {
        case (KernelCandidate::ORIG):
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getBackground();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Original kernel does not exist");
            break;
        case (KernelCandidate::PCA):
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getBackground();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Pca kernel does not exist");
            break;
        case (KernelCandidate::RECENT):
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getBackground();
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getBackground();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "No kernels exist");
            break;
        default:
            throw std::logic_error("Invalid CandidateSwitch, cannot get background");
    }
}

getCandidateRating()

template<typename _PixelT >

double lsst::ip::diffim::KernelCandidate< _PixelT >::getCandidateRating ( ) const

inlinevirtual

Return Candidate rating.

Note

Required method for use by SpatialCell; e.g. total flux

Implements lsst::afw::math::SpatialCellCandidate.

Definition at line 91 of file KernelCandidate.h.

{ return _coreFlux; }

getChi2()

double lsst::afw::math::SpatialCellImageCandidate::getChi2 ( ) const

inlineinherited

Return the candidate's chi^2.

Definition at line 146 of file SpatialCell.h.

{ return _chi2; }

getDifferenceImage() [1/2]

template<typename PixelT >

lsst::afw::image::MaskedImage< PixelT > lsst::ip::diffim::KernelCandidate< PixelT >::getDifferenceImage

(

CandidateSwitch

cand

)

Calculate associated difference image using internal solutions.

Definition at line 366 of file KernelCandidate.cc.

                                                                                                {
    switch (cand) {
        case (KernelCandidate::ORIG):
            if (_kernelSolutionOrig)
                return getDifferenceImage(_kernelSolutionOrig->getKernel(),
                                          _kernelSolutionOrig->getBackground());
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Original kernel does not exist");
            break;
        case (KernelCandidate::PCA):
            if (_kernelSolutionPca)
                return getDifferenceImage(_kernelSolutionPca->getKernel(),
                                          _kernelSolutionPca->getBackground());
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Pca kernel does not exist");
            break;
        case (KernelCandidate::RECENT):
            if (_kernelSolutionPca)
                return getDifferenceImage(_kernelSolutionPca->getKernel(),
                                          _kernelSolutionPca->getBackground());
            else if (_kernelSolutionOrig)
                return getDifferenceImage(_kernelSolutionOrig->getKernel(),
                                          _kernelSolutionOrig->getBackground());
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "No kernels exist");
            break;
        default:
            throw std::logic_error("Invalid CandidateSwitch, cannot get diffim");
    }
}

getDifferenceImage() [2/2]

template<typename PixelT >

lsst::afw::image::MaskedImage< PixelT > lsst::ip::diffim::KernelCandidate< PixelT >::getDifferenceImage	(	std::shared_ptr< afw::math::Kernel >	kernel,
		double	background )

Calculate associated difference image using input kernel and background.

Note

Useful for spatial modeling

Definition at line 398 of file KernelCandidate.cc.

                                                                    {
    /* Make diffim and set chi2 from result */
    afwImage::MaskedImage<PixelT> diffIm =
            convolveAndSubtract(*_templateMaskedImage, *_scienceMaskedImage, *kernel, background);
    return diffIm;
}

getHeight()

static int lsst::afw::math::SpatialCellImageCandidate::getHeight ( )

inlinestaticinherited

Return the height of the image that getImage should return.

Definition at line 143 of file SpatialCell.h.

{ return _height; }

getId()

int lsst::afw::math::SpatialCellCandidate::getId ( ) const

inlineinherited

Return the candidate's unique ID.

Definition at line 102 of file SpatialCell.h.

{ return _id; }

getImage()

template<typename PixelT >

std::shared_ptr< typename KernelCandidate< PixelT >::ImageT const > lsst::ip::diffim::KernelCandidate< PixelT >::getImage

(

)

const

Definition at line 332 of file KernelCandidate.cc.

                                                                                                    {
    return getKernelImage(KernelCandidate::ORIG);
}

getKernel()

template<typename PixelT >

std::shared_ptr< lsst::afw::math::Kernel > lsst::ip::diffim::KernelCandidate< PixelT >::getKernel

(

CandidateSwitch

cand

)

const

Return results of kernel solution.

Definition at line 219 of file KernelCandidate.cc.

                                                                                              {
    switch (cand) {
        case (KernelCandidate::ORIG):
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getKernel();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Original kernel does not exist");
            break;
        case (KernelCandidate::PCA):
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getKernel();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Pca kernel does not exist");
            break;
        case (KernelCandidate::RECENT):
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getKernel();
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getKernel();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "No kernels exist");
            break;
        default:
            throw std::logic_error("Invalid CandidateSwitch, cannot get kernel");
    }
}

getKernelImage()

template<typename PixelT >

std::shared_ptr< typename KernelCandidate< PixelT >::ImageT > lsst::ip::diffim::KernelCandidate< PixelT >::getKernelImage

(

CandidateSwitch

cand

)

const

Definition at line 303 of file KernelCandidate.cc.

                                    {
    switch (cand) {
        case (KernelCandidate::ORIG):
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig->makeKernelImage();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Original kernel does not exist");
            break;
        case (KernelCandidate::PCA):
            if (_kernelSolutionPca)
                return _kernelSolutionPca->makeKernelImage();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Pca kernel does not exist");
            break;
        case (KernelCandidate::RECENT):
            if (_kernelSolutionPca)
                return _kernelSolutionPca->makeKernelImage();
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig->makeKernelImage();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "No kernels exist");
            break;
        default:
            throw std::logic_error("Invalid CandidateSwitch, cannot get kernel image");
    }
}

getKernelSolution()

template<typename PixelT >

std::shared_ptr< StaticKernelSolution< PixelT > > lsst::ip::diffim::KernelCandidate< PixelT >::getKernelSolution

(

CandidateSwitch

cand

)

const

Definition at line 337 of file KernelCandidate.cc.

                                    {
    switch (cand) {
        case (KernelCandidate::ORIG):
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig;
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Original kernel does not exist");
            break;
        case (KernelCandidate::PCA):
            if (_kernelSolutionPca)
                return _kernelSolutionPca;
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Pca kernel does not exist");
            break;
        case (KernelCandidate::RECENT):
            if (_kernelSolutionPca)
                return _kernelSolutionPca;
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig;
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "No kernels exist");
            break;
        default:
            throw std::logic_error("Invalid CandidateSwitch, cannot get solution");
    }
}

getKsum()

template<typename PixelT >

double lsst::ip::diffim::KernelCandidate< PixelT >::getKsum

(

CandidateSwitch

cand

)

const

Definition at line 275 of file KernelCandidate.cc.

                                                                  {
    switch (cand) {
        case (KernelCandidate::ORIG):
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getKsum();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Original kernel does not exist");
            break;
        case (KernelCandidate::PCA):
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getKsum();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "Pca kernel does not exist");
            break;
        case (KernelCandidate::RECENT):
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getKsum();
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getKsum();
            else
                throw LSST_EXCEPT(pexExcept::RuntimeError, "No kernels exist");
            break;
        default:
            throw std::logic_error("Invalid CandidateSwitch, cannot get kSum");
    }
}

getScienceMaskedImage()

template<typename _PixelT >

MaskedImagePtr lsst::ip::diffim::KernelCandidate< _PixelT >::getScienceMaskedImage ( )

inline

Definition at line 100 of file KernelCandidate.h.

{return _scienceMaskedImage;}

getSource()

template<typename _PixelT >

SourcePtr lsst::ip::diffim::KernelCandidate< _PixelT >::getSource ( ) const

inline

Return the original source.

Definition at line 95 of file KernelCandidate.h.

{ return _source; }

getStatus()

Status lsst::afw::math::SpatialCellCandidate::getStatus ( ) const

inlineinherited

Return the candidate's status.

Definition at line 104 of file SpatialCell.h.

{ return _status; }

getTemplateMaskedImage()

template<typename _PixelT >

MaskedImagePtr lsst::ip::diffim::KernelCandidate< _PixelT >::getTemplateMaskedImage ( )

inline

Return pointers to the image pixels used in kernel determination.

Definition at line 99 of file KernelCandidate.h.

{return _templateMaskedImage;}

getWidth()

static int lsst::afw::math::SpatialCellImageCandidate::getWidth ( )

inlinestaticinherited

Return the width of the image that getImage should return.

Definition at line 138 of file SpatialCell.h.

{ return _width; }

getXCenter()

float lsst::afw::math::SpatialCellCandidate::getXCenter ( ) const

inlineinherited

Return the object's column-centre.

Definition at line 88 of file SpatialCell.h.

{ return _xCenter; }

getYCenter()

float lsst::afw::math::SpatialCellCandidate::getYCenter ( ) const

inlineinherited

Return the object's row-centre.

Definition at line 91 of file SpatialCell.h.

{ return _yCenter; }

instantiate()

virtual bool lsst::afw::math::SpatialCellCandidate::instantiate ( )

inlinevirtualinherited

Do anything needed to make this candidate usable.

Definition at line 94 of file SpatialCell.h.

{ return true; }

isBad()

virtual bool lsst::afw::math::SpatialCellCandidate::isBad ( ) const

inlinevirtualinherited

Is this candidate unacceptable?

Definition at line 108 of file SpatialCell.h.

{ return (_status == BAD); }

isInitialized()

template<typename _PixelT >

bool lsst::ip::diffim::KernelCandidate< _PixelT >::isInitialized ( ) const

inline

Definition at line 128 of file KernelCandidate.h.

{return _isInitialized;}

setCandidateRating()

virtual void lsst::afw::math::SpatialCellCandidate::setCandidateRating ( double )

inlinevirtualinherited

Set the candidate's rating.

Definition at line 99 of file SpatialCell.h.

{}

setChi2()

void lsst::afw::math::SpatialCellImageCandidate::setChi2 ( double chi2 )

inlineinherited

Set the candidate's chi^2.

Definition at line 148 of file SpatialCell.h.

{ _chi2 = chi2; }

setHeight()

static void lsst::afw::math::SpatialCellImageCandidate::setHeight ( int height )

inlinestaticinherited

Set the height of the image that getImage should return.

Definition at line 141 of file SpatialCell.h.

{ _height = height; }

setStatus()

void lsst::afw::math::SpatialCellCandidate::setStatus ( Status status )

inherited

Set the candidate's status.

Definition at line 52 of file SpatialCell.cc.

                                                  {
    switch (status) {
        case GOOD:
        case UNKNOWN:
            _status = status;
            return;
        case BAD:
            _status = status;
            return;
    }
 
    throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                      (boost::format("Saw unknown status %d") % status).str());
}

setWidth()

static void lsst::afw::math::SpatialCellImageCandidate::setWidth ( int width )

inlinestaticinherited

Set the width of the image that getImage should return.

Definition at line 136 of file SpatialCell.h.

{ _width = width; }

---

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+d0b6459378/include/lsst/ip/diffim/KernelCandidate.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/ip_diffim/g180d380827+d0b6459378/src/KernelCandidate.cc