lsst.afw.detection::FootprintSet Class Reference

A set of Footprints, associated with a MaskedImage. More...

#include <FootprintSet.h>

Inheritance diagram for lsst.afw.detection::FootprintSet:

Public Types
typedef std::vector < Footprint::Ptr >	FootprintList
	The FootprintSet's set of Footprints. More...
Public Types inherited from lsst.daf.base::Citizen
enum	{ magicSentinel = 0xdeadbeef }
typedef unsigned long	memId
	Type of the block's ID. More...
typedef memId(*	memNewCallback )(const memId cid)
	A function used to register a callback. More...
typedef memId(*	memCallback )(const Citizen *ptr)

Public Member Functions
template<typename ImagePixelT >
	FootprintSet (image::Image< ImagePixelT > const &img, Threshold const &threshold, int const npixMin=1, bool const setPeaks=true)
template<typename MaskPixelT >
	FootprintSet (image::Mask< MaskPixelT > const &img, Threshold const &threshold, int const npixMin=1)
template<typename ImagePixelT , typename MaskPixelT >
	FootprintSet (image::MaskedImage< ImagePixelT, MaskPixelT > const &img, Threshold const &threshold, std::string const &planeName="", int const npixMin=1, bool const setPeaks=true)
	Find a FootprintSet given a MaskedImage and a threshold. More...
template<typename ImagePixelT , typename MaskPixelT >
	FootprintSet (image::MaskedImage< ImagePixelT, MaskPixelT > const &img, Threshold const &threshold, int x, int y, std::vector< boost::shared_ptr< Peak >> const *peaks=NULL)
	FootprintSet (geom::Box2I region)
	FootprintSet (FootprintSet const &)
	FootprintSet (FootprintSet const &set, int rGrow, FootprintControl const &ctrl)
	FootprintSet (FootprintSet const &set, int rGrow, bool isotropic=true)
	FootprintSet (FootprintSet const &footprints1, FootprintSet const &footprints2, bool const includePeaks)
FootprintSet &	operator= (FootprintSet const &rhs)
	Assignment operator. More...
void	swap (FootprintSet &rhs)
boost::shared_ptr< FootprintList >	getFootprints ()
void	setFootprints (boost::shared_ptr< FootprintList > footprints)
boost::shared_ptr < FootprintList const > const	getFootprints () const
void	makeSources (afw::table::SourceCatalog &catalog) const
	Add a new record corresponding to each footprint to a SourceCatalog. More...
void	setRegion (geom::Box2I const &region)
geom::Box2I const	getRegion () const
boost::shared_ptr < image::Image < FootprintIdPixel > >	insertIntoImage (const bool relativeIDs) const
template<typename MaskPixelT >
void	setMask (image::Mask< MaskPixelT > *mask, std::string const &planeName)
template<typename MaskPixelT >
void	setMask (boost::shared_ptr< image::Mask< MaskPixelT > > mask, std::string const &planeName)
void	merge (FootprintSet const &rhs, int tGrow=0, int rGrow=0, bool isotropic=true)
template<typename ImagePixelT , typename MaskPixelT >
void	makeHeavy (image::MaskedImage< ImagePixelT, MaskPixelT > const &mimg, HeavyFootprintCtrl const *ctrl=NULL)
Public Member Functions inherited from lsst.daf.base::Citizen
	Citizen (const std::type_info &)
	Citizen (Citizen const &)
	~Citizen ()
Citizen &	operator= (Citizen const &)
std::string	repr () const
	Return a string representation of a Citizen. More...
void	markPersistent (void)
	Mark a Citizen as persistent and not destroyed until process end. More...
memId	getId () const
	Return the Citizen's ID. More...

Private Attributes
boost::shared_ptr< FootprintList >	_footprints
	the Footprints of detected objects More...
geom::Box2I	_region
	The corners of the MaskedImage that the detections live in. More...

Additional Inherited Members
Static Public Member Functions inherited from lsst.daf.base::Citizen
static bool	hasBeenCorrupted ()
	Check all allocated blocks for corruption. More...
static memId	getNextMemId ()
	Return the memId of the next object to be allocated. More...
static int	init ()
	Called once when the memory system is being initialised. More...
static int	census (int, memId startingMemId=0)
	How many active Citizens are there? More...
static void	census (std::ostream &stream, memId startingMemId=0)
	Print a list of all active Citizens to stream, sorted by ID. More...
static const std::vector < const Citizen * > *	census ()
	Return a (newly allocated) std::vector of active Citizens sorted by ID. More...
static memId	setNewCallbackId (memId id)
	Call the NewCallback when block is allocated. More...
static memId	setDeleteCallbackId (memId id)
	Call the current DeleteCallback when block is deleted. More...
static memNewCallback	setNewCallback (memNewCallback func)
	Set the NewCallback function. More...
static memCallback	setDeleteCallback (memCallback func)
	Set the DeleteCallback function. More...
static memCallback	setCorruptionCallback (memCallback func)
	Set the CorruptionCallback function. More...

Detailed Description

A set of Footprints, associated with a MaskedImage.

Examples:

footprintFunctor.cc, and spatialCellExample.cc.

Definition at line 53 of file FootprintSet.h.

Member Typedef Documentation

typedef std::vector<Footprint::Ptr> lsst.afw.detection::FootprintSet::FootprintList

The FootprintSet's set of Footprints.

Examples:

footprintFunctor.cc.

Definition at line 57 of file FootprintSet.h.

Constructor & Destructor Documentation

template<typename ImagePixelT >

lsst.afw.detection::FootprintSet::FootprintSet	(	image::Image< ImagePixelT > const &	img,
		Threshold const &	threshold,
		int const	npixMin = 1,
		bool const	setPeaks = true
	)

Parameters

img	Image to search for objects
threshold	threshold to find objects
npixMin	minimum number of pixels in an object
setPeaks	should I set the Peaks list?

Definition at line 741 of file FootprintSet.cc.

  : lsst::daf::base::Citizen(typeid(this)),
    _footprints(new FootprintList()),
    _region(img.getBBox())
{
    typedef float VariancePixelT;
     
    findFootprints<ImagePixelT, afw::image::MaskPixel, VariancePixelT, ThresholdLevel_traits>(
        _footprints.get(), 
        _region, 
        img,
        NULL,
        threshold.getValue(img), threshold.getIncludeMultiplier(), threshold.getPolarity(),
        npixMin,
        setPeaks
    );
}

template<typename MaskPixelT >

lsst.afw.detection::FootprintSet::FootprintSet	(	image::Mask< MaskPixelT > const &	msk,
		Threshold const &	threshold,
		int const	npixMin = 1
	)

Parameters

msk	Image to search for objects
threshold	threshold to find objects
npixMin	minimum number of pixels in an object

Definition at line 769 of file FootprintSet.cc.

  : lsst::daf::base::Citizen(typeid(this)),
    _footprints(new FootprintList()),
    _region(msk.getBBox())
{
    switch (threshold.getType()) {
      case Threshold::BITMASK:
          findFootprints<MaskPixelT, MaskPixelT, float, ThresholdBitmask_traits>(
            _footprints.get(), _region, msk, NULL, threshold.getValue(), threshold.getIncludeMultiplier(),
            threshold.getPolarity(), npixMin, false);
        break;

      case Threshold::VALUE:
        findFootprints<MaskPixelT, MaskPixelT, float, ThresholdLevel_traits>(
            _footprints.get(), _region, msk, NULL, threshold.getValue(), threshold.getIncludeMultiplier(),
            threshold.getPolarity(), npixMin, false);
        break;

      default:
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          "You must specify a numerical threshold value with a Mask");
    }
}

template<typename ImagePixelT , typename MaskPixelT >

lsst.afw.detection::FootprintSet::FootprintSet	(	image::MaskedImage< ImagePixelT, MaskPixelT > const &	img,
		Threshold const &	threshold,
		std::string const &	planeName = "",
		int const	npixMin = 1,
		bool const	setPeaks = true
	)

Find a FootprintSet given a MaskedImage and a threshold.

Go through an image, finding sets of connected pixels above threshold and assembling them into Footprints; the resulting set of objects is returned as an array<Footprint::Ptr>

If threshold.getPolarity() is true, pixels above the Threshold are assembled into Footprints; if it's false, then pixels below Threshold are processed (Threshold will probably have to be below the background level for this to make sense, e.g. for difference imaging)

Parameters

img	MaskedImage to search for objects
threshold	threshold for footprints (controls size)
planeName	mask plane to set (if != "")
npixMin	minimum number of pixels in an object
setPeaks	should I set the Peaks list?

Definition at line 810 of file FootprintSet.cc.

  : lsst::daf::base::Citizen(typeid(this)),
    _footprints(new FootprintList()),
    _region(
        geom::Point2I(maskedImg.getX0(), maskedImg.getY0()),
        geom::Extent2I(maskedImg.getWidth(), maskedImg.getHeight())
    )
{
    typedef typename image::MaskedImage<ImagePixelT, MaskPixelT>::Variance::Pixel VariancePixelT;
    // Find the Footprints    
    switch (threshold.getType()) {
      case Threshold::PIXEL_STDEV:
        findFootprints<ImagePixelT, MaskPixelT, VariancePixelT, ThresholdPixelLevel_traits>(
            _footprints.get(), 
            _region,
            *maskedImg.getImage(), 
            maskedImg.getVariance().get(), 
            threshold.getValue(maskedImg),
            threshold.getIncludeMultiplier(),
            threshold.getPolarity(),
            npixMin,
            setPeaks
                                                                                  );
        break;
      default:
        findFootprints<ImagePixelT, MaskPixelT, VariancePixelT, ThresholdLevel_traits>(
            _footprints.get(), 
            _region,
            *maskedImg.getImage(), 
            maskedImg.getVariance().get(), 
            threshold.getValue(maskedImg),
            threshold.getIncludeMultiplier(),
            threshold.getPolarity(),
            npixMin,
            setPeaks
                                                                                  );
        break;
    }
    // Set Mask if requested    
    if (planeName == "") {
        return;
    }
    //
    // Define the maskPlane
    //
    const typename image::Mask<MaskPixelT>::Ptr mask = maskedImg.getMask();
    mask->addMaskPlane(planeName);

    MaskPixelT const bitPlane = mask->getPlaneBitMask(planeName);
    //
    // Set the bits where objects are detected
    //
    typedef image::Mask<MaskPixelT> MaskT;

    class MaskFootprint : public detection::FootprintFunctor<MaskT> {
    public:
        MaskFootprint(MaskT const& mimage,
                      MaskPixelT bit) : detection::FootprintFunctor<MaskT>(mimage), _bit(bit) {}

        void operator()(typename MaskT::xy_locator loc, int, int) {
            *loc |= _bit;
        }
    private:
        MaskPixelT _bit;
    };

    MaskFootprint maskit(*maskedImg.getMask(), bitPlane);
    for (FootprintList::const_iterator fiter = _footprints->begin();         
         fiter != _footprints->end(); ++fiter
    ) {
        Footprint::Ptr const foot = *fiter;

        maskit.apply(*foot);
    }
}

template<typename ImagePixelT , typename MaskPixelT >

lsst.afw.detection::FootprintSet::FootprintSet	(	image::MaskedImage< ImagePixelT, MaskPixelT > const &	img,
		Threshold const &	threshold,
		int	x,
		int	y,
		std::vector< boost::shared_ptr< Peak >> const *	peaks = NULL
	)

Return a FootprintSet consisting a Footprint containing the point (x, y) (if above threshold)

Todo:

Implement this. There's RHL Pan-STARRS code to do it, but it isn't yet converted to LSST C++

Parameters

img	Image to search for objects
threshold	threshold to find objects
x	Footprint should include this pixel (column)
y	Footprint should include this pixel (row)
peaks	Footprint should include at most one of these peaks

Definition at line 898 of file FootprintSet.cc.

  : lsst::daf::base::Citizen(typeid(this)),
    _footprints(new FootprintList()),
    _region(geom::Point2I(img.getX0(), img.getY0()),
            geom::Extent2I(img.getWidth(), img.getHeight())) 
{
    throw LSST_EXCEPT(lsst::pex::exceptions::LogicError, "NOT IMPLEMENTED");
}

lsst.afw.detection::FootprintSet::FootprintSet

(

geom::Box2I

region

)

Construct an empty FootprintSet given a region that its footprints would have lived in

Parameters

region

the desired region

Definition at line 1315 of file FootprintSet.cc.

  :
    lsst::daf::base::Citizen(typeid(this)),
    _footprints(PTR(FootprintList)(new FootprintList)), _region(region) {
}

lsst.afw.detection::FootprintSet::FootprintSet

(

FootprintSet const &

rhs

)

Copy constructor

Parameters

rhs	the input FootprintSet

Definition at line 1324 of file FootprintSet.cc.

  :
    lsst::daf::base::Citizen(typeid(this)),
    _footprints(new FootprintList), _region(rhs._region)
{
    _footprints->reserve(rhs._footprints->size());
    for (FootprintSet::FootprintList::const_iterator ptr = rhs._footprints->begin(),
             end = rhs._footprints->end(); ptr != end; ++ptr) {
        _footprints->push_back(PTR(Footprint)(new Footprint(**ptr)));
    }
}

lsst.afw.detection::FootprintSet::FootprintSet	(	detection::FootprintSet const &	rhs,
		int	rGrow,
		detection::FootprintControl const &	ctrl
	)

Definition at line 1407 of file FootprintSet.cc.

    : lsst::daf::base::Citizen(typeid(this)), _footprints(new FootprintList), _region(rhs._region)
{
    if (ngrow == 0) {
        FootprintSet fs = rhs;
        swap(fs);                       // Swap the new FootprintSet into place
        return;
    } else if (ngrow < 0) {
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          str(boost::format("I cannot grow by negative numbers: %d") % ngrow));
    }

    detection::FootprintSet fs = mergeFootprintSets(FootprintSet(rhs.getRegion()), 0, rhs, ngrow, ctrl);
    swap(fs);                           // Swap the new FootprintSet into place
}

lsst.afw.detection::FootprintSet::FootprintSet	(	FootprintSet const &	rhs,
		int	r,
		bool	isotropic = true
	)

Grow all the Footprints in the input FootprintSet, returning a new FootprintSet

The output FootprintSet may contain fewer Footprints, as some may well have been merged

Parameters

rhs	the input FootprintSet
r	Grow Footprints by r pixels
isotropic	Grow isotropically (as opposed to a Manhattan metric)

Note

Isotropic grows are significantly slower

Definition at line 1383 of file FootprintSet.cc.

    : lsst::daf::base::Citizen(typeid(this)), _footprints(new FootprintList), _region(rhs._region)
{
    if (r == 0) {
        FootprintSet fs = rhs;
        swap(fs);                       // Swap the new FootprintSet into place
        return;
    } else if (r < 0) {
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          (boost::format("I cannot grow by negative numbers: %d") % r).str());
    }

    detection::FootprintControl const ctrl(true, isotropic);
    detection::FootprintSet fs = mergeFootprintSets(FootprintSet(rhs.getRegion()), 0, rhs, r, ctrl);
    swap(fs);                           // Swap the new FootprintSet into place
}

lsst.afw.detection::FootprintSet::FootprintSet	(	FootprintSet const &	fs1,
		FootprintSet const &	fs2,
		bool const	includePeaks
	)

Return the FootprintSet corresponding to the merge of two input FootprintSets

Todo:

Implement this. There's RHL Pan-STARRS code to do it, but it isn't yet converted to LSST C++

Definition at line 1431 of file FootprintSet.cc.

    : lsst::daf::base::Citizen(typeid(this)),
      _footprints(new FootprintList()),
      _region(fs1._region)
{
    _region.include(fs2._region);
    throw LSST_EXCEPT(lsst::pex::exceptions::LogicError, "NOT IMPLEMENTED");
}

Member Function Documentation

boost::shared_ptr< FootprintList > lsst.afw.detection::FootprintSet::getFootprints ( )

inline

: Return the Footprints of detected objects

Definition at line 168 of file FootprintSet.h.

{ return _footprints; } 

boost::shared_ptr< FootprintList const> const lsst.afw.detection::FootprintSet::getFootprints ( ) const

inline

Retun the Footprints of detected objects

Definition at line 178 of file FootprintSet.h.

{ return _footprints; }

geom::Box2I const lsst.afw.detection::FootprintSet::getRegion ( ) const

inline

Return the corners of the MaskedImage

Definition at line 195 of file FootprintSet.h.

{ return _region; } 

boost::shared_ptr< image::Image< detection::FootprintIdPixel > > lsst.afw.detection::FootprintSet::insertIntoImage

(

const bool

relativeIDs

)

const

Return an Image with pixels set to the Footprints in the FootprintSet

Returns

an image::Image::Ptr

Parameters

relativeIDs

Use IDs starting at 0 (rather than the ones in the Footprints)

Definition at line 1451 of file FootprintSet.cc.

        {
    PTR(image::Image<detection::FootprintIdPixel>) im(
        new image::Image<detection::FootprintIdPixel>(_region)
    );
    *im = 0;

    detection::FootprintIdPixel id = 0;
    for (FootprintList::const_iterator fiter = _footprints->begin(); 
         fiter != _footprints->end(); fiter++
    ) {
        Footprint::Ptr const foot = *fiter;
        
        if (relativeIDs) {
            id++;
        } else {
            id = foot->getId();
        }
        
        foot->insertIntoImage(*im.get(), id);
    }
    
    return im;
}

template<typename ImagePixelT , typename MaskPixelT >

void lsst.afw.detection::FootprintSet::makeHeavy	(	image::MaskedImage< ImagePixelT, MaskPixelT > const &	mimg,
		HeavyFootprintCtrl const *	ctrl = NULL
	)

Convert all the Footprints in the FootprintSet to be HeavyFootprints

Parameters

mimg	the image providing pixel values
ctrl	Control how we manipulate HeavyFootprints

Definition at line 1483 of file FootprintSet.cc.

{
    HeavyFootprintCtrl ctrl_s = HeavyFootprintCtrl();

    if (!ctrl) {
        ctrl = &ctrl_s;
    }

    for (FootprintList::iterator ptr = _footprints->begin(),
                                          end = _footprints->end(); ptr != end; ++ptr) {
        ptr->reset(new detection::HeavyFootprint<ImagePixelT, MaskPixelT>(**ptr, mimg, ctrl));
    }
}

void lsst.afw.detection::FootprintSet::makeSources

(

afw::table::SourceCatalog &

catalog

)

const

Add a new record corresponding to each footprint to a SourceCatalog.

Parameters

[in,out]

catalog

Catalog to append new sources to.

The new sources will have their footprints set to point to the footprints in the footprint set; they will not be deep-copied.

Definition at line 1500 of file FootprintSet.cc.

        {
    for (FootprintList::const_iterator i = _footprints->begin(); i != _footprints->end(); ++i) {
        PTR(afw::table::SourceRecord) r = cat.addNew();
        r->setFootprint(*i);
    }
}

void lsst.afw.detection::FootprintSet::merge	(	detection::FootprintSet const &	rhs,
		int	tGrow = 0,
		int	rGrow = 0,
		bool	isotropic = true
	)

Merge a FootprintSet into *this

Parameters

rhs	the Footprints to merge
tGrow	No. of pixels to grow this Footprints
rGrow	No. of pixels to grow rhs Footprints
isotropic	Use (expensive) isotropic grow

Definition at line 1349 of file FootprintSet.cc.

{
    detection::FootprintControl const ctrl(true, isotropic);
    detection::FootprintSet fs = mergeFootprintSets(*this, tGrow, rhs, rGrow, ctrl);
    swap(fs);                           // Swap the new FootprintSet into place
}

detection::FootprintSet & lsst.afw.detection::FootprintSet::operator=

(

FootprintSet const &

rhs

)

Assignment operator.

Definition at line 1339 of file FootprintSet.cc.

                                                        {
    FootprintSet tmp(rhs);
    swap(tmp);                          // See Meyers, Effective C++, Item 11    
    return *this;
}

void lsst.afw.detection::FootprintSet::setFootprints ( boost::shared_ptr< FootprintList >  footprints )

inline

: Set the Footprints of detected objects

Definition at line 173 of file FootprintSet.h.

{ _footprints = footprints; }

template<typename MaskPixelT >

void lsst.afw.detection::FootprintSet::setMask ( image::Mask< MaskPixelT > *  mask, std::string const &  planeName  )

inline

Parameters

mask	Set bits in the mask
planeName	Here's the name of the mask plane to fit

Definition at line 202 of file FootprintSet.h.

      {
        setMaskFromFootprintList(
            mask, 
            _footprints,                // calling getFootprints() confuses clang++ 3.0 and leaks memory
            image::Mask<MaskPixelT>::getPlaneBitMask(planeName)
        );        
    }

template<typename MaskPixelT >

void lsst.afw.detection::FootprintSet::setMask ( boost::shared_ptr< image::Mask< MaskPixelT > >  mask, std::string const &  planeName  )

inline

Parameters

mask	Set bits in the mask
planeName	Here's the name of the mask plane to fit

Definition at line 214 of file FootprintSet.h.

      {
        setMask(mask.get(), planeName);
    }

void lsst.afw.detection::FootprintSet::setRegion

(

geom::Box2I const &

region

)

Set the corners of the FootprintSet's MaskedImage to region

N.b. updates all the Footprints' regions too

Parameters

region

desired region

Definition at line 1365 of file FootprintSet.cc.

  {
    _region = region;

    for (FootprintSet::FootprintList::iterator ptr = _footprints->begin(),
             end = _footprints->end(); ptr != end; ++ptr
    ) {
        (*ptr)->setRegion(region);
    }
}

void lsst.afw.detection::FootprintSet::swap ( FootprintSet &  rhs )

inline

Definition at line 157 of file FootprintSet.h.

                                 {
        using std::swap;                    // See Meyers, Effective C++, Item 25        
        swap(*_footprints, *rhs.getFootprints());
        geom::Box2I rhsRegion = rhs.getRegion();
        rhs.setRegion(getRegion());
        setRegion(rhsRegion);
    }

Member Data Documentation

boost::shared_ptr<FootprintList> lsst.afw.detection::FootprintSet::_footprints

private

the Footprints of detected objects

Definition at line 228 of file FootprintSet.h.

geom::Box2I lsst.afw.detection::FootprintSet::_region

private

The corners of the MaskedImage that the detections live in.

Definition at line 229 of file FootprintSet.h.

---

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

• /home/lsstsw/stack/Linux64/afw/10.0-40-g4349866+2/include/lsst/afw/detection/FootprintSet.h
• /home/lsstsw/stack/Linux64/afw/10.0-40-g4349866+2/src/detection/FootprintSet.cc