lsst::meas::algorithms::PsfImagePca< ImageT > Class Template Reference

#include <ImagePca.h>

Inheritance diagram for lsst::meas::algorithms::PsfImagePca< ImageT >:

Public Types
using	ImageList = std::vector< std::shared_ptr< ImageT > >

Public Member Functions
	PsfImagePca (bool constantWeight=true, int border=3)
	Ctor. More...
virtual void	analyze ()
	Generate eigenimages that are normalised and background-subtracted. More...
void	addImage (std::shared_ptr< ImageT > img, double flux=0.0)
	Add an image to the set to be analyzed. More...
ImageList	getImageList () const
	Return the list of images being analyzed. More...
lsst::geom::Extent2I const	getDimensions () const
	Return the dimension of the images being analyzed. More...
std::shared_ptr< ImageT >	getMean () const
	Return the mean of the images in ImagePca's list. More...
virtual double	updateBadPixels (unsigned long mask, int const ncomp)
	Update the bad pixels (i.e. More...
std::vector< double > const &	getEigenValues () const
	Return Eigen values. More...
ImageList const &	getEigenImages () const
	Return Eigen images. More...

Detailed Description

template<typename ImageT>
class lsst::meas::algorithms::PsfImagePca< ImageT >

Definition at line 45 of file ImagePca.h.

Member Typedef Documentation

ImageList

template<typename ImageT >

using lsst::afw::image::ImagePca< ImageT >::ImageList = std::vector<std::shared_ptr<ImageT> >

inherited

Definition at line 47 of file ImagePca.h.

Constructor & Destructor Documentation

PsfImagePca()

template<typename ImageT >

lsst::meas::algorithms::PsfImagePca< ImageT >::PsfImagePca ( bool  constantWeight = true, int  border = 3  )

inlineexplicit

Ctor.

Definition at line 49 of file ImagePca.h.

            : Super(constantWeight), _border(border) {}

Member Function Documentation

addImage()

template<typename ImageT >

void lsst::afw::image::ImagePca< ImageT >::addImage ( std::shared_ptr< ImageT >  img, double  flux = 0.0  )

inherited

Add an image to the set to be analyzed.

Parameters

img	Image to add to set
flux	Image's flux

Exceptions

lsst::pex::exceptions::LengthError

if all the images aren't the same size

Definition at line 64 of file ImagePca.cc.

                                                                      {
    if (_imageList.empty()) {
        _dimensions = img->getDimensions();
    } else {
        if (getDimensions() != img->getDimensions()) {
            throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                              (boost::format("Dimension mismatch: saw %dx%d; expected %dx%d") %
                               img->getWidth() % img->getHeight() % _dimensions.getX() % _dimensions.getY())
                                      .str());
        }
    }
 
    if (flux == 0.0) {
        throw LSST_EXCEPT(lsst::pex::exceptions::OutOfRangeError, "Flux may not be zero");
    }
 
    _imageList.push_back(img);
    _fluxList.push_back(flux);
}

analyze()

template<typename ImageT >

void lsst::meas::algorithms::PsfImagePca< ImageT >::analyze

virtual

Generate eigenimages that are normalised and background-subtracted.

The background subtraction ensures PSF variation doesn't couple with small background errors.

Reimplemented from lsst::afw::image::ImagePca< ImageT >.

Definition at line 41 of file ImagePca.cc.

                                  {
    Super::analyze();
 
    typename Super::ImageList const &eImageList = this->getEigenImages();
    typename Super::ImageList::const_iterator iter = eImageList.begin(), end = eImageList.end();
    for (size_t i = 0; iter != end; ++i, ++iter) {
        std::shared_ptr<ImageT> eImage = *iter;
 
        /*
         * Normalise eigenImages to have a maximum of 1.0.  For n > 0 they
         * (should) have mean == 0, so we can't use that to normalize
         */
        afw::math::Statistics stats = afw::math::makeStatistics(*eImage, (afw::math::MIN | afw::math::MAX));
        double const min = stats.getValue(afw::math::MIN);
        double const max = stats.getValue(afw::math::MAX);
 
        double const extreme = (fabs(min) > max) ? min : max;
        if (extreme != 0.0) {
            *eImage /= extreme;
        }
 
        /*
         * Estimate and subtract the mean background level from the i > 0
         * eigen images; if we don't do that then PSF variation can get mixed
         * with subtle variations in the background and potentially amplify
         * them disasterously.
         *
         * It is not at all clear that doing this is a good idea; it'd be
         * better to get the sky level right in the first place.
         */
        if (i > 0 && _border > 0) { /* not the zeroth KL component */
            int const height = eImage->getHeight();
            int const width = eImage->getWidth();
            double background;
            if (2 * _border >= std::min(height, width)) {
                // _Border consumes the entire image
                background = afw::math::makeStatistics(*afw::image::GetImage<ImageT>::getImage(eImage),
                                                       afw::math::MEDIAN)
                                     .getValue();
            } else {
                // Use the median of the edge pixels
 
                // If ImageT is a MaskedImage, unpack the Image
                std::shared_ptr<typename afw::image::GetImage<ImageT>::type> eImageIm =
                        afw::image::GetImage<ImageT>::getImage(eImage);
 
                int const nEdge = width * height - (width - 2 * _border) * (height - 2 * _border);
                std::vector<double> edgePixels(nEdge);
 
                std::vector<double>::iterator bi = edgePixels.begin();
 
                typedef typename afw::image::GetImage<ImageT>::type::x_iterator imIter;
                int y = 0;
                for (; y != _border; ++y) {  // Bottom border of eImage
                    for (imIter ptr = eImageIm->row_begin(y), end = eImageIm->row_end(y); ptr != end;
                         ++ptr, ++bi) {
                        *bi = *ptr;
                    }
                }
                for (; y != height - _border; ++y) {  // Left and right borders of eImage
                    for (imIter ptr = eImageIm->row_begin(y), end = eImageIm->x_at(_border, y); ptr != end;
                         ++ptr, ++bi) {
                        *bi = *ptr;
                    }
                    for (imIter ptr = eImageIm->x_at(width - _border, y), end = eImageIm->row_end(y);
                         ptr != end; ++ptr, ++bi) {
                        *bi = *ptr;
                    }
                }
                for (; y != height; ++y) {  // Top border of eImage
                    for (imIter ptr = eImageIm->row_begin(y), end = eImageIm->row_end(y); ptr != end;
                         ++ptr, ++bi) {
                        *bi = *ptr;
                    }
                }
                assert(std::distance(edgePixels.begin(), bi) == nEdge);
 
                background = afw::math::makeStatistics(edgePixels, afw::math::MEDIAN).getValue();
            }
            *eImage -= background;
        }
    }
}

getDimensions()

template<typename ImageT >

lsst::geom::Extent2I const lsst::afw::image::ImagePca< ImageT >::getDimensions ( ) const

inlineinherited

Return the dimension of the images being analyzed.

Definition at line 75 of file ImagePca.h.

{ return _dimensions; }

getEigenImages()

template<typename ImageT >

ImageList const& lsst::afw::image::ImagePca< ImageT >::getEigenImages ( ) const

inlineinherited

Return Eigen images.

Definition at line 100 of file ImagePca.h.

{ return _eigenImages; }

getEigenValues()

template<typename ImageT >

std::vector<double> const& lsst::afw::image::ImagePca< ImageT >::getEigenValues ( ) const

inlineinherited

Return Eigen values.

Definition at line 98 of file ImagePca.h.

{ return _eigenValues; }

getImageList()

template<typename ImageT >

ImagePca< ImageT >::ImageList lsst::afw::image::ImagePca< ImageT >::getImageList

inherited

Return the list of images being analyzed.

Definition at line 85 of file ImagePca.cc.

                                                                        {
    return _imageList;
}

getMean()

template<typename ImageT >

std::shared_ptr< ImageT > lsst::afw::image::ImagePca< ImageT >::getMean

inherited

Return the mean of the images in ImagePca's list.

Definition at line 90 of file ImagePca.cc.

                                                      {
    if (_imageList.empty()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError, "You haven't provided any images");
    }
 
    std::shared_ptr<ImageT> mean(new ImageT(getDimensions()));
    *mean = static_cast<typename ImageT::Pixel>(0);
 
    for (typename ImageList::const_iterator ptr = _imageList.begin(), end = _imageList.end(); ptr != end;
         ++ptr) {
        *mean += **ptr;
    }
    *mean /= _imageList.size();
 
    return mean;
}

updateBadPixels()

template<typename ImageT >

double lsst::afw::image::ImagePca< ImageT >::updateBadPixels ( unsigned long  mask, int const  ncomp  )

virtualinherited

Update the bad pixels (i.e.

those for which (value & mask) != 0) based on the current PCA decomposition; if none is available, use the mean of the good pixels

Parameters

mask	Mask defining bad pixels
ncomp	Number of components to use in estimate

Returns

the maximum change made to any pixel

N.b. the work is actually done in do_updateBadPixels as the code only makes sense and compiles when we are doing a PCA on a set of MaskedImages

Definition at line 386 of file ImagePca.cc.

                                                                            {
    return do_updateBadPixels<ImageT>(typename ImageT::image_category(), _imageList, _fluxList, _eigenImages,
                                      mask, ncomp);
}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_algorithms/22.0.1-32-gf62ce7b1+aa4237961e/include/lsst/meas/algorithms/ImagePca.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_algorithms/22.0.1-32-gf62ce7b1+aa4237961e/src/ImagePca.cc