Namespace lsst::afw::detection

namespace detection

Typedefs

typedef std::uint64_t FootprintIdPixel

Pixel type for FootprintSet::insertIntoImage()

This is independent of the template parameters for FootprintSet, and including it within FootprintSet makes it difficult for SWIG to interpret the type.

typedef afw::table::ColumnViewT<PeakRecord> PeakColumnView
typedef afw::table::CatalogT<PeakRecord> PeakCatalog
typedef afw::table::CatalogT<PeakRecord const> ConstPeakCatalog

Functions

std::shared_ptr<Footprint> mergeFootprints(Footprint const &footprint1, Footprint const &footprint2)

Merges two Footprints appends their peaks, and unions their spans, returning a new Footprint. Region is not preserved, and is set to an empty lsst::geom::Box2I object.

std::vector<lsst::geom::Box2I> footprintToBBoxList(Footprint const &footprint)

Return a list of BBoxs, whose union contains exactly the pixels in the footprint, neither more nor less.

Useful in generating sets of meas::algorithms::Defects for the ISR

Parameters

  • footprint: Footprint to turn into bounding box list

template<typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT> makeHeavyFootprint(Footprint const &foot, lsst::afw::image::MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT> const &img, HeavyFootprintCtrl const *ctrl = NULL)

Create a HeavyFootprint with footprint defined by the given Footprint and pixel values from the given MaskedImage.

template<typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
std::shared_ptr<HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT>> mergeHeavyFootprints(HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT> const &h1, HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT> const &h2)

Sum the two given HeavyFootprints h1 and h2, returning a HeavyFootprint with the union footprint, and summed pixels where they overlap. The peak list is the union of the two inputs.

std::ostream &operator<<(std::ostream &os, PeakRecord const &record)
Threshold createThreshold(const double value, const std::string type = "value", const bool polarity = true)

Factory method for creating Threshold objects

Return

desired Threshold

Parameters

  • value: value of threshold

  • type: string representation of a ThresholdType. This parameter is optional. Allowed values are: “variance”, “value”, “stdev”, “pixel_stdev”

  • polarity: If true detect positive objects, false for negative

class Footprint : public lsst::afw::table::io::PersistableFacade<lsst::afw::detection::Footprint>, public lsst::afw::table::io::Persistable
#include <Footprint.h>

Class to describe the properties of a detected object from an image

A Footprint is designed to be constructed with information about a detected object in an image. Internally a Footprint holds a SpanSet which is used to describe the location of the object in the image (the x, y pixel locations which are considered part of the object). In addition a Footprint contains a PeakCatalog which is used to store the location and intensity of peaks in the detection.

Subclassed by lsst::afw::detection::HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT >

class FootprintControl
#include <FootprintCtrl.h>

A Control Object for Footprints, controlling e.g. how they are grown

class FootprintMergeList
#include <FootprintMerge.h>

List of Merged Footprints.

Stores a vector of FootprintMerges and SourceRecords that contain the union of different footprints and which filters it was detected in. Individual Footprints from a SourceCatalog can be added to the vector (note that any SourceRecords with parent!=0 will be skipped). If a Footprint overlaps an existing FootprintMerge, the Footprint will be added to it. If not, then a new FootprintMerge will be created and added to the vector.

The search algorithm uses a brute force approach over the current list. This should be fine if we are operating on smallish number of objects, such as at the tract level.

class FootprintSet
#include <FootprintSet.h>

A set of Footprints, associated with a MaskedImage

class GaussianPsf : public lsst::afw::table::io::PersistableFacade<GaussianPsf>, public lsst::afw::detection::Psf
#include <GaussianPsf.h>

A circularly symmetric Gaussian Psf class with no spatial variation, intended mostly for testing purposes.

This class is essentially an alternate implementation of meas::algorithms::SingleGaussianPsf; While SingleGaussianPsf inherits from ImagePsf and KernelPsf, and hence delegates to those various operations relating to the PSF model image (e.g. computeShape()), GaussianPsf computes these analytically.

template<typename ImagePixelT, typename MaskPixelT = lsst::afw::image::MaskPixel, typename VariancePixelT = lsst::afw::image::VariancePixel>
class HeavyFootprint : public lsst::afw::table::io::PersistableFacade<HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT>>, public lsst::afw::detection::Footprint
#include <HeavyFootprint.h>

A set of pixels in an Image, including those pixels’ actual values

class HeavyFootprintCtrl
#include <FootprintCtrl.h>

A control object for HeavyFootprints

class PeakRecord : public lsst::afw::table::BaseRecord
#include <Peak.h>

Record class that represents a peak in a Footprint

class PeakTable : public lsst::afw::table::BaseTable
#include <Peak.h>

Table class for Peaks in Footprints.

class Psf : public lsst::afw::table::io::PersistableFacade<Psf>, public Storable
#include <Psf.h>

A polymorphic base class for representing an image’s Point Spread Function

Most of a Psf’s functionality involves its evaluation at a position and color, either or both of which may be unspecified (which will result in evaluation at some average position or color). Unlike the closely-related Kernel class, there is no requirement that a Psf have a well-defined spatial function or any parameters. Psfs are not necessarily continuous, and the dimensions of image of the Psf at a point may not be fixed.

Psfs have two methods for getting at image at a point:

  • the image returned by computeImage() is in the same coordinate system as the pixelized image

  • the image returned by computeKernelImage() is in an offset coordinate system with the point P at (0,0); this implies that the image (x0,y0) will be negative

Because P does not need to have integer coordinates, these two images are fractionally offset from each other and we use interpolation to get (1) from (2).

Psfs are immutable - derived classes should have no non-const methods, and hence should be fully-defined after construction. This allows shared_ptrs to Psfs to be passed around and shared between objects without concern for whether they will be unexpectedly modified.

In most cases, Psf derived classes should inherit from meas::algorithms::ImagePsf or meas::algorithms::KernelPsf, as these will provide default implementions for several member functions.

Subclassed by lsst::afw::detection::GaussianPsf, lsst::meas::algorithms::ImagePsf

class Threshold
#include <Threshold.h>

A Threshold is used to pass a threshold value to detection algorithms

The threshold may be a simple value (type == VALUE), or in units of the image standard deviation. Alternatively you may specify that you’ll provide the standard deviation (type == STDEV) or variance (type == VARIANCE)

Note that the constructor is not declared explicit, so you may pass a bare threshold, and it’ll be interpreted as a VALUE.