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

#include <ImagePca.h>

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

Public Member Functions
	PsfImagePca (bool constantWeight=true, int border=3)
	Ctor. More...
virtual void	analyze ()
Public Member Functions inherited from lsst::afw::image::ImagePca< ImageT >
	ImagePca (bool constantWeight=true)
	ctor More...
virtual	~ImagePca ()
void	addImage (typename ImageT::Ptr img, double flux=0.0)
ImageList	getImageList () const
	Return the list of images being analyzed. More...
geom::Extent2I const	getDimensions () const
	Return the dimension of the images being analyzed. More...
ImageT::Ptr	getMean () const
virtual double	updateBadPixels (unsigned long mask, int const ncomp)
std::vector< double > const &	getEigenValues () const
	Return Eigen values. More...
ImageList const &	getEigenImages () const
	Return Eigen images. More...

Private Types
typedef afw::image::ImagePca < ImageT >	Super
	Base class. More...

Private Attributes
int const	_border
	Border width for background subtraction. More...

Additional Inherited Members
Public Types inherited from lsst::afw::image::ImagePca< ImageT >
typedef boost::shared_ptr< ImageT >	Ptr
typedef boost::shared_ptr < const ImageT >	ConstPtr
typedef std::vector< typename ImageT::Ptr >	ImageList

Detailed Description

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

Definition at line 46 of file ImagePca.h.

Member Typedef Documentation

template<typename ImageT>

typedef afw::image::ImagePca<ImageT> lsst::meas::algorithms::PsfImagePca< ImageT >::Super

private

Base class.

Definition at line 47 of file ImagePca.h.

Constructor & Destructor Documentation

template<typename ImageT>

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

inlineexplicit

Ctor.

Definition at line 50 of file ImagePca.h.

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

Member Function Documentation

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) {
        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
                typename afw::image::GetImage<ImageT>::type::Ptr 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;
        }
    }
}

Member Data Documentation

template<typename ImageT>

int const lsst::meas::algorithms::PsfImagePca< ImageT >::_border

private

Border width for background subtraction.

Definition at line 58 of file ImagePca.h.

---

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

• /home/lsstsw/stack/Linux64/meas_algorithms/11.0-2-gb8b8ce7/include/lsst/meas/algorithms/ImagePca.h
• /home/lsstsw/stack/Linux64/meas_algorithms/11.0-2-gb8b8ce7/src/ImagePca.cc