lsst::ip::diffim::KernelCandidateDetection< PixelT > Class Template Reference

Search through images for Footprints with no masked pixels. More...

#include <KernelCandidateDetection.h>

Public Types
typedef boost::shared_ptr < KernelCandidateDetection >	Ptr
typedef boost::shared_ptr < lsst::afw::image::MaskedImage < PixelT > >	MaskedImagePtr

Public Member Functions
	KernelCandidateDetection (lsst::pex::policy::Policy const &policy)
virtual	~KernelCandidateDetection ()
void	apply (MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage)
	Runs Detection on a single image for significant peaks, and checks returned Footprints for Masked pixels. More...
bool	growCandidate (lsst::afw::detection::Footprint::Ptr fp, int fpGrowPix, MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage)
std::vector < lsst::afw::detection::Footprint::Ptr >	getFootprints ()

Private Attributes
lsst::pex::policy::Policy	_policy
lsst::afw::image::MaskPixel	_badBitMask
std::vector < lsst::afw::detection::Footprint::Ptr >	_footprints

Detailed Description

template<typename PixelT>
class lsst::ip::diffim::KernelCandidateDetection< PixelT >

Search through images for Footprints with no masked pixels.

Note

Runs detection on the template; searches through both images for masked pixels

Parameters

templateMaskedImage	MaskedImage that will be convolved with kernel
scienceMaskedImage	MaskedImage to subtract convolved template from
policy	Policy for operations; in particular object detection

Definition at line 35 of file KernelCandidateDetection.h.

Member Typedef Documentation

template<typename PixelT >

typedef boost::shared_ptr<lsst::afw::image::MaskedImage<PixelT> > lsst::ip::diffim::KernelCandidateDetection< PixelT >::MaskedImagePtr

Definition at line 38 of file KernelCandidateDetection.h.

template<typename PixelT >

typedef boost::shared_ptr<KernelCandidateDetection> lsst::ip::diffim::KernelCandidateDetection< PixelT >::Ptr

Definition at line 37 of file KernelCandidateDetection.h.

Constructor & Destructor Documentation

template<typename PixelT >

lsst::ip::diffim::KernelCandidateDetection< PixelT >::KernelCandidateDetection

(

lsst::pex::policy::Policy const &

policy

)

Definition at line 34 of file KernelCandidateDetection.cc.

          :
        _policy(policy), 
        _badBitMask(0), 
        _footprints(std::vector<lsst::afw::detection::Footprint::Ptr>()) {

        std::vector<std::string> detBadMaskPlanes = _policy.getStringArray("badMaskPlanes");
        for (std::vector<std::string>::iterator mi = detBadMaskPlanes.begin(); 
             mi != detBadMaskPlanes.end(); ++mi){
            try {
                _badBitMask |= afwImage::Mask<afwImage::MaskPixel>::getPlaneBitMask(*mi);
            } catch (pexExcept::Exception& e) {
                pexLog::TTrace<6>("lsst.ip.diffim.KernelCandidateDetection",
                                  "Cannot update bad bit mask with %s", (*mi).c_str());
                pexLog::TTrace<7>("lsst.ip.diffim.KernelCandidateDetection",
                                  e.what());
            }
        }
        pexLog::TTrace<4>("lsst.ip.diffim.KernelCandidateDetection", 
                          "Using bad bit mask %d", _badBitMask);
    }

template<typename PixelT >

virtual lsst::ip::diffim::KernelCandidateDetection< PixelT >::~KernelCandidateDetection ( )

inlinevirtual

Definition at line 42 of file KernelCandidateDetection.h.

{};

Member Function Documentation

template<typename PixelT >

void lsst::ip::diffim::KernelCandidateDetection< PixelT >::apply	(	MaskedImagePtr const &	templateMaskedImage,
		MaskedImagePtr const &	scienceMaskedImage
	)

Runs Detection on a single image for significant peaks, and checks returned Footprints for Masked pixels.

Note

Accepts two MaskedImages, one of which is to be convolved to match the other. The Detection package is run on either the image to be convolved (assumed to be higher S/N than the other image), or the image to not be convolved (assumed lower S/N; however if you run detection on a very deep template, you might not have significant S/N objects in the science image). The subimages associated with each returned Footprint in both images are checked for Masked pixels; Footprints containing Masked pixels are rejected. The Footprints are grown by an amount specified in the Policy. The acceptible Footprints are returned in a vector.

Returns

Vector of "clean" Footprints around which Image Subtraction Kernels will be built.

Definition at line 78 of file KernelCandidateDetection.cc.

          {
        
        // Parse the Policy
        int fpNpixMin                = _policy.getInt("fpNpixMin");
        int fpGrowPix                = _policy.getInt("fpGrowPix");
        
        bool detOnTemplate           = _policy.getBool("detOnTemplate");
        double detThreshold          = _policy.getDouble("detThreshold");
        std::string detThresholdType = _policy.getString("detThresholdType");

        /* reset private variables */
        _footprints.clear();

        // List of Footprints
        boost::shared_ptr<std::vector<afwDetect::Footprint::Ptr> > footprintListInPtr;

        // Find detections
        afwDetect::Threshold threshold = 
            afwDetect::createThreshold(detThreshold, detThresholdType);

        if (detOnTemplate == true) {
            afwDetect::FootprintSet footprintSet(
                *(templateMaskedImage), 
                threshold,
                "",
                fpNpixMin);
            // Get the associated footprints

            footprintListInPtr = footprintSet.getFootprints();
            pexLog::TTrace<4>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                              "Found %d total footprints in template above %.3f %s",
                              footprintListInPtr->size(), detThreshold, detThresholdType.c_str());
        }
        else {
            afwDetect::FootprintSet footprintSet(
                *(scienceMaskedImage), 
                threshold,
                "",
                fpNpixMin);
            
            footprintListInPtr = footprintSet.getFootprints();
            pexLog::TTrace<4>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                              "Found %d total footprints in science image above %.3f %s",
                              footprintListInPtr->size(), detThreshold, detThresholdType.c_str());
        }    
        
        // Iterate over footprints, look for "good" ones
        for (std::vector<afwDetect::Footprint::Ptr>::iterator i = footprintListInPtr->begin(); 
             i != footprintListInPtr->end(); ++i) {
            
            pexLog::TTrace<6>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                              "Processing footprint %d", (*i)->getId());
            growCandidate((*i), fpGrowPix, templateMaskedImage, scienceMaskedImage);
        }
        
        if (_footprints.size() == 0) {
            throw LSST_EXCEPT(pexExcept::Exception, 
                              "Unable to find any footprints for Psf matching");
        }
        
        pexLog::TTrace<1>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                          "Found %d clean footprints above threshold %.3f",
                          _footprints.size(), detThreshold);
        
    }

template<typename PixelT >

std::vector<lsst::afw::detection::Footprint::Ptr> lsst::ip::diffim::KernelCandidateDetection< PixelT >::getFootprints ( )

inline

Definition at line 52 of file KernelCandidateDetection.h.

{return _footprints;};

template<typename PixelT >

bool lsst::ip::diffim::KernelCandidateDetection< PixelT >::growCandidate	(	lsst::afw::detection::Footprint::Ptr	fp,
		int	fpGrowPix,
		MaskedImagePtr const &	templateMaskedImage,
		MaskedImagePtr const &	scienceMaskedImage
	)

Definition at line 148 of file KernelCandidateDetection.cc.

          {
        int fpNpixMax = _policy.getInt("fpNpixMax");

        /* Functor to search through the images for masked pixels within *
         * candidate footprints.  Might want to consider changing the default
         * mask planes it looks through.
         */
        FindSetBits<afwImage::Mask<afwImage::MaskPixel> > fsb;
        
        afwGeom::Box2I fpBBox = fp->getBBox();
        /* Failure Condition 1) 
         * 
         * Footprint has too many pixels off the bat.  We don't want to throw
         * away these guys, they have alot of signal!  Lets just use the core of
         * it.
         * 
         */
        if (fp->getNpix() > fpNpixMax) {
            pexLog::TTrace<6>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                              "Footprint has too many pix: %d (max =%d)", 
                              fp->getNpix(), fpNpixMax);
            
            int xc = int(0.5 * (fpBBox.getMinX() + fpBBox.getMaxX()));
            int yc = int(0.5 * (fpBBox.getMinY() + fpBBox.getMaxY()));
            afwDetect::Footprint::Ptr fpCore(
                new afwDetect::Footprint(afwGeom::Box2I(afwGeom::Point2I(xc, yc), afwGeom::Extent2I(1,1)))
                );
            return growCandidate(fpCore, fpGrowPix, templateMaskedImage, scienceMaskedImage);
        } 

        pexLog::TTrace<8>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                          "Original footprint in parent : %d,%d -> %d,%d -> %d,%d",
                          fpBBox.getMinX(), fpBBox.getMinY(), 
                          int(0.5 * (fpBBox.getMinX() + fpBBox.getMaxX())),
                          int(0.5 * (fpBBox.getMinY() + fpBBox.getMaxY())),
                          fpBBox.getMaxX(), fpBBox.getMaxY());
        
        /* Grow the footprint
         * flag true  = isotropic grow   = slow
         * flag false = 'manhattan grow' = fast
         * 
         * The manhattan masks are rotated 45 degree w.r.t. the coordinate
         * system.  They intersect the vertices of the rectangle that would
         * connect pixels (X0,Y0) (X1,Y0), (X0,Y1), (X1,Y1).
         * 
         * The isotropic masks do take considerably longer to grow and are
         * basically elliptical.  X0, X1, Y0, Y1 delimit the extent of the
         * ellipse.
         * 
         * In both cases, since the masks aren't rectangles oriented with
         * the image coordinate system, when we DO extract such rectangles
         * as subimages for kernel fitting, some corner pixels can be found
         * in multiple subimages.
         * 
         */
        afwDetect::Footprint::Ptr fpGrow = 
            afwDetect::growFootprint(fp, fpGrowPix, false);
        
        /* Next we look at the image within this Footprint.  
         */
        afwGeom::Box2I fpGrowBBox = fpGrow->getBBox();
        pexLog::TTrace<8>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                          "Grown footprint in parent : %d,%d -> %d,%d -> %d,%d",
                          fpGrowBBox.getMinX(), fpGrowBBox.getMinY(), 
                          int(0.5 * (fpGrowBBox.getMinX() + fpGrowBBox.getMaxX())),
                          int(0.5 * (fpGrowBBox.getMinY() + fpGrowBBox.getMaxY())),
                          fpGrowBBox.getMaxX(), fpGrowBBox.getMaxY());

        /* Failure Condition 2) 
         * Grown off the image
         */
        if (!(templateMaskedImage->getBBox().contains(fpGrowBBox))) {
            pexLog::TTrace<6>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                              "Footprint grown off image"); 
            return false;
        }
        
        /* Grab subimages; report any exception */
        bool subimageHasFailed = false;
        try {
            afwImage::MaskedImage<PixelT> templateSubimage(*templateMaskedImage, fpGrowBBox);
            afwImage::MaskedImage<PixelT> scienceSubimage(*scienceMaskedImage, fpGrowBBox);
            
            // Search for any masked pixels within the footprint
            fsb.apply(*(templateSubimage.getMask()));
            if (fsb.getBits() & _badBitMask) {
                pexLog::TTrace<6>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                                  "Footprint has masked pix (vals=%d) in image to convolve", 
                                  fsb.getBits()); 
                subimageHasFailed = true;
            }
            
            fsb.apply(*(scienceSubimage.getMask()));
            if (fsb.getBits() & _badBitMask) {
                pexLog::TTrace<6>("lsst.ip.diffim.KernelCandidateDetection.apply", 
                                  "Footprint has masked pix (vals=%d) in image not to convolve", 
                                  fsb.getBits());
                subimageHasFailed = true;
            }
            
        } catch (pexExcept::Exception& e) {
            pexLog::TTrace<6>("lsst.ip.diffim.KernelCandidateDetection.apply",
                              "Exception caught extracting Footprint");
            pexLog::TTrace<7>("lsst.ip.diffim.KernelCandidateDetection.apply",
                              e.what());
            subimageHasFailed = true;
        }
        if (subimageHasFailed) {
            return false;
        } else {
            /* We have a good candidate */
            _footprints.push_back(fpGrow);
            return true;
        }
    }

Member Data Documentation

template<typename PixelT >

lsst::afw::image::MaskPixel lsst::ip::diffim::KernelCandidateDetection< PixelT >::_badBitMask

private

Definition at line 56 of file KernelCandidateDetection.h.

template<typename PixelT >

std::vector<lsst::afw::detection::Footprint::Ptr> lsst::ip::diffim::KernelCandidateDetection< PixelT >::_footprints

private

Definition at line 57 of file KernelCandidateDetection.h.

template<typename PixelT >

lsst::pex::policy::Policy lsst::ip::diffim::KernelCandidateDetection< PixelT >::_policy

private

Definition at line 52 of file KernelCandidateDetection.h.

---

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

• /lsst/home/lsstsw/stack/Linux64/ip_diffim/master-gcec1da163f+63/include/lsst/ip/diffim/KernelCandidateDetection.h
• /lsst/home/lsstsw/stack/Linux64/ip_diffim/master-gcec1da163f+63/src/KernelCandidateDetection.cc