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

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

#include <KernelCandidateDetection.h>

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

Public Member Functions
	KernelCandidateDetection (lsst::daf::base::PropertySet const &ps)
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.
bool	growCandidate (std::shared_ptr< lsst::afw::detection::Footprint > fp, int fpGrowPix, MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage)
std::vector< std::shared_ptr< lsst::afw::detection::Footprint > >	getFootprints ()

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
ps	PropertySet for operations; in particular object detection

Definition at line 35 of file KernelCandidateDetection.h.

Member Typedef Documentation

MaskedImagePtr

template<typename PixelT >

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

Definition at line 38 of file KernelCandidateDetection.h.

Ptr

template<typename PixelT >

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

Definition at line 37 of file KernelCandidateDetection.h.

Constructor & Destructor Documentation

KernelCandidateDetection()

template<typename PixelT >

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

(

lsst::daf::base::PropertySet const &

ps

)

Definition at line 35 of file KernelCandidateDetection.cc.

          :
        _ps(ps.deepCopy()),
        _badBitMask(0),
        _footprints(std::vector<std::shared_ptr<lsst::afw::detection::Footprint>>()) {
 
        std::vector<std::string> detBadMaskPlanes = _ps->getArray<std::string>("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) {
                LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection",
                           "Cannot update bad bit mask with %s", (*mi).c_str());
                LOGL_DEBUG("TRACE4.ip.diffim.KernelCandidateDetection",
                           e.what());
            }
        }
        LOGL_DEBUG("TRACE2.ip.diffim.KernelCandidateDetection",
                   "Using bad bit mask %d", _badBitMask);
    }

~KernelCandidateDetection()

template<typename PixelT >

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

inlinevirtual

Definition at line 42 of file KernelCandidateDetection.h.

{};

Member Function Documentation

apply()

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 ps. The acceptible Footprints are returned in a vector.

Returns

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

Definition at line 79 of file KernelCandidateDetection.cc.

          {
 
        // Parse the ps
        int fpNpixMin                = _ps->getAsInt("fpNpixMin");
        int fpGrowPix                = _ps->getAsInt("fpGrowPix");
 
        bool detOnTemplate           = _ps->getAsBool("detOnTemplate");
        double detThreshold          = _ps->getAsDouble("detThreshold");
        std::string detThresholdType = _ps->getAsString("detThresholdType");
 
        /* reset private variables */
        _footprints.clear();
 
        // List of Footprints
        std::shared_ptr<std::vector<std::shared_ptr<afwDetect::Footprint>>> 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();
            LOGL_DEBUG("TRACE2.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();
            LOGL_DEBUG("TRACE2.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<std::shared_ptr<afwDetect::Footprint>>::iterator i = footprintListInPtr->begin();
             i != footprintListInPtr->end(); ++i) {
 
            growCandidate((*i), fpGrowPix, templateMaskedImage, scienceMaskedImage);
        }
 
        if (_footprints.size() == 0) {
            throw LSST_EXCEPT(pexExcept::Exception,
                              "Unable to find any footprints for Psf matching");
        }
 
        LOGL_DEBUG("TRACE1.ip.diffim.KernelCandidateDetection.apply",
                   "Found %d clean footprints above threshold %.3f",
                   _footprints.size(), detThreshold);
 
    }

getFootprints()

template<typename PixelT >

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

inline

Definition at line 52 of file KernelCandidateDetection.h.

{return _footprints;};

growCandidate()

template<typename PixelT >

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

Definition at line 147 of file KernelCandidateDetection.cc.

          {
        int fpNpixMax = _ps->getAsInt("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;
 
        geom::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->getArea() > static_cast<std::size_t>(fpNpixMax)) {
            LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection.apply",
                       "Footprint has too many pix: %d (max =%d)",
                       fp->getArea(), fpNpixMax);
 
            int xc = int(0.5 * (fpBBox.getMinX() + fpBBox.getMaxX()));
            int yc = int(0.5 * (fpBBox.getMinY() + fpBBox.getMaxY()));
            std::shared_ptr<afwDetect::Footprint> fpCore(
                new afwDetect::Footprint(
                    std::make_shared<afwGeom::SpanSet>(geom::Box2I(geom::Point2I(xc, yc),
                                                       geom::Extent2I(1,1))))
                );
            return growCandidate(fpCore, fpGrowPix, templateMaskedImage, scienceMaskedImage);
        }
 
        LOGL_DEBUG("TRACE5.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.
         *
         */
        std::shared_ptr<afwDetect::Footprint> fpGrow = std::make_shared<afwDetect::Footprint>(
            fp->getSpans()->dilated(fpGrowPix, afwGeom::Stencil::MANHATTAN)
        );
 
        /* Next we look at the image within this Footprint.
         */
        geom::Box2I fpGrowBBox = fpGrow->getBBox();
        LOGL_DEBUG("TRACE5.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))) {
            LOGL_DEBUG("TRACE3.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) {
                LOGL_DEBUG("TRACE3.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) {
                LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection.apply",
                           "Footprint has masked pix (vals=%d) in image not to convolve",
                           fsb.getBits());
                subimageHasFailed = true;
            }
 
        } catch (pexExcept::Exception& e) {
            LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection.apply",
                       "Exception caught extracting Footprint");
            LOGL_DEBUG("TRACE4.ip.diffim.KernelCandidateDetection.apply",
                       e.what());
            subimageHasFailed = true;
        }
        if (subimageHasFailed) {
            return false;
        } else {
            /* We have a good candidate */
            _footprints.push_back(fpGrow);
            return true;
        }
    }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/ip_diffim/g5d89126706+46afc7f72d/include/lsst/ip/diffim/KernelCandidateDetection.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/ip_diffim/g5d89126706+46afc7f72d/src/KernelCandidateDetection.cc