lsst::afw::detection Namespace Reference

Namespaces
	detail
	detectionLib
	footprintMerge
	multiband
	peak
	utils

Classes
class	Footprint
	Class to describe the properties of a detected object from an image. More...
class	FootprintControl
	A Control Object for Footprints, controlling e.g. More...
class	FootprintFactory
class	FootprintMerge
class	FootprintMergeList
	List of Merged Footprints. More...
class	FootprintSet
	A set of Footprints, associated with a MaskedImage. More...
class	GaussianPsf
	A circularly symmetric Gaussian Psf class with no spatial variation, intended mostly for testing purposes. More...
class	HeavyFootprint
	A set of pixels in an Image, including those pixels' actual values. More...
class	HeavyFootprintCtrl
	A control object for HeavyFootprints. More...
class	IdSpan
	run-length code for part of object More...
struct	IdSpanCompar
	comparison functor; sort by ID, then by row (y), then by column range start (x0) More...
class	PeakRecord
	Record class that represents a peak in a Footprint. More...
class	PeakTable
	Table class for Peaks in Footprints. More...
class	Psf
	A polymorphic base class for representing an image's Point Spread Function. More...
class	Threshold
	A Threshold is used to pass a threshold value to detection algorithms. More...

Typedefs
typedef std::uint64_t	FootprintIdPixel
	Pixel type for FootprintSet::insertIntoImage() More...
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. More...
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. More...
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. More...
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. More...
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. More...
	PYBIND11_MODULE (footprint, mod)
	PYBIND11_MODULE (footprintCtrl, mod)
	PYBIND11_MODULE (footprintMerge, mod)
	PYBIND11_MODULE (footprintSet, mod)
	PYBIND11_MODULE (gaussianPsf, mod)
	PYBIND11_MODULE (heavyFootprint, mod)
	PYBIND11_MODULE (peak, mod)
	PYBIND11_MODULE (psf, mod)
	PYBIND11_MODULE (threshold, mod)
int	resolve_alias (const std::vector< int > &aliases, int id)
	Follow a chain of aliases, returning the final resolved value. More...

Typedef Documentation

ConstPeakCatalog

typedef afw::table::CatalogT<PeakRecord const> lsst::afw::detection::ConstPeakCatalog

Definition at line 235 of file Peak.h.

FootprintIdPixel

typedef std::uint64_t lsst::afw::detection::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.

Definition at line 48 of file FootprintSet.h.

PeakCatalog

typedef afw::table::CatalogT<PeakRecord> lsst::afw::detection::PeakCatalog

Definition at line 234 of file Peak.h.

PeakColumnView

typedef afw::table::ColumnViewT<PeakRecord> lsst::afw::detection::PeakColumnView

Definition at line 233 of file Peak.h.

Function Documentation

createThreshold()

Threshold lsst::afw::detection::createThreshold	(	const double	value,
		const std::string	type = "value",
		const bool	polarity = true
	)

Factory method for creating Threshold objects.

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

Returns

desired Threshold

Definition at line 109 of file Threshold.cc.

                                                                                            {
    return Threshold(value, Threshold::parseTypeString(typeStr), polarity);
}

footprintToBBoxList()

std::vector< lsst::geom::Box2I > lsst::afw::detection::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

Definition at line 358 of file Footprint.cc.

                                                                         {
    typedef std::uint16_t PixelT;
    lsst::geom::Box2I fpBBox = footprint.getBBox();
    std::shared_ptr<image::Image<PixelT>> idImage(new image::Image<PixelT>(fpBBox));
    *idImage = 0;
    int const height = fpBBox.getHeight();
    lsst::geom::Extent2I shift(fpBBox.getMinX(), fpBBox.getMinY());
    footprint.getSpans()->setImage(*idImage, static_cast<PixelT>(1), fpBBox, true);

    std::vector<lsst::geom::Box2I> bboxes;
    /*
     * Our strategy is to find a row of pixels in the Footprint and interpret it as the first
     * row of a rectangular set of pixels.  We then extend this rectangle upwards as far as it
     * will go, and define that as a BBox.  We clear all those pixels, and repeat until there
     * are none left.  I.e. a Footprint will get cut up like this:
     *
     *       .555...
     *       22.3314
     *       22.331.
     *       .000.1.
     * (as shown in Footprint_1.py)
     */

    int y0 = 0;  // the first row with non-zero pixels in it
    while (y0 < height) {
        lsst::geom::Box2I bbox;  // our next BBox
        for (int y = y0; y != height; ++y) {
            // Look for a set pixel in this row
            image::Image<PixelT>::x_iterator begin = idImage->row_begin(y), end = idImage->row_end(y);
            image::Image<PixelT>::x_iterator first = std::find(begin, end, 1);

            if (first != end) {  // A pixel is set in this row
                image::Image<PixelT>::x_iterator last = std::find(first, end, 0) - 1;
                int const x0 = first - begin;
                int const x1 = last - begin;

                std::fill(first, last + 1, 0);  // clear pixels; we don't want to see them again

                bbox.include(lsst::geom::Point2I(x0, y));  // the LLC
                bbox.include(lsst::geom::Point2I(x1, y));  // the LRC; initial guess for URC

                // we found at least one pixel so extend the BBox upwards
                for (++y; y != height; ++y) {
                    if (std::find(idImage->at(x0, y), idImage->at(x1 + 1, y), 0) != idImage->at(x1 + 1, y)) {
                        break;  // some pixels weren't set, so the BBox stops here, (actually in previous row)
                    }
                    std::fill(idImage->at(x0, y), idImage->at(x1 + 1, y), 0);

                    bbox.include(lsst::geom::Point2I(x1, y));  // the new URC
                }

                bbox.shift(shift);
                bboxes.push_back(bbox);
            } else {
                y0 = y + 1;
            }
            break;
        }
    }

    return bboxes;
}

makeHeavyFootprint()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT> lsst::afw::detection::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.

Definition at line 148 of file HeavyFootprint.h.

                                               {
    return HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT>(foot, img, ctrl);
}

mergeFootprints()

std::shared_ptr< Footprint > lsst::afw::detection::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.

Definition at line 333 of file Footprint.cc.

                                                                                                   {
    // Bail out early if the schemas are not the same
    if (footprint1.getPeaks().getSchema() != footprint2.getPeaks().getSchema()) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "Cannot merge Footprints with different Schemas");
    }

    // Merge the SpanSets
    auto unionedSpanSet = footprint1.getSpans()->union_(*(footprint2.getSpans()));

    // Construct merged Footprint
    auto mergedFootprint = std::make_shared<Footprint>(unionedSpanSet, footprint1.getPeaks().getSchema());
    // Copy over the peaks from both footprints
    mergedFootprint->setPeakCatalog(PeakCatalog(footprint1.getPeaks().getTable()));
    PeakCatalog& peaks = mergedFootprint->getPeaks();
    peaks.reserve(footprint1.getPeaks().size() + footprint2.getPeaks().size());
    peaks.insert(peaks.end(), footprint1.getPeaks().begin(), footprint1.getPeaks().end(), true);
    peaks.insert(peaks.end(), footprint2.getPeaks().begin(), footprint2.getPeaks().end(), true);

    // Sort the PeaksCatalog according to value
    mergedFootprint->sortPeaks();

    return mergedFootprint;
}

mergeHeavyFootprints()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

std::shared_ptr< HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT > > lsst::afw::detection::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.

Definition at line 132 of file HeavyFootprint.cc.

                                                                           {
    // Merge the Footprints (by merging the Spans)
    std::shared_ptr<Footprint> foot = mergeFootprints(h1, h2);

    // Find the union bounding-box
    lsst::geom::Box2I bbox(h1.getBBox());
    bbox.include(h2.getBBox());

    // Create union-bb-sized images and insert the heavies
    image::MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT> im1(bbox);
    image::MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT> im2(bbox);
    h1.insert(im1);
    h2.insert(im2);
    // Add the pixels
    im1 += im2;

    // Build new HeavyFootprint from the merged spans and summed pixels.
    return std::make_shared<HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT>>(*foot, im1);
}

operator<<()

std::ostream & lsst::afw::detection::operator<<	(	std::ostream &	os,
		PeakRecord const &	record
	)

Definition at line 95 of file Peak.cc.

                                                                 {
    return os << (boost::format("%d: (%d,%d)  (%.3f,%.3f)") % record.getId() % record.getIx() %
                  record.getIy() % record.getFx() % record.getFy());
}

PYBIND11_MODULE() [1/9]

lsst::afw::detection::PYBIND11_MODULE	(	threshold	,
		mod
	)

Definition at line 35 of file threshold.cc.

                                {
    py::class_<Threshold, std::shared_ptr<Threshold>> clsThreshold(mod, "Threshold");

    /* Member types and enums */
    py::enum_<Threshold::ThresholdType>(clsThreshold, "ThresholdType")
            .value("VALUE", Threshold::ThresholdType::VALUE)
            .value("BITMASK", Threshold::ThresholdType::BITMASK)
            .value("STDEV", Threshold::ThresholdType::STDEV)
            .value("VARIANCE", Threshold::ThresholdType::VARIANCE)
            .value("PIXEL_STDEV", Threshold::ThresholdType::PIXEL_STDEV)
            .export_values();

    /* Constructors */
    clsThreshold.def(
            py::init<double const, typename Threshold::ThresholdType const, bool const, double const>(),
            "value"_a, "type"_a = Threshold::VALUE, "polarity"_a = true, "includeMultiplier"_a = 1.0);

    /* Members */
    clsThreshold.def("getType", &Threshold::getType);
    clsThreshold.def_static("parseTypeString", Threshold::parseTypeString);
    clsThreshold.def_static("getTypeString", Threshold::getTypeString);
    clsThreshold.def("getValue", (double (Threshold::*)(const double) const) & Threshold::getValue,
                     "param"_a = -1);
    //
    //    template<typename ImageT>
    //    double getValue(ImageT const& image) const;
    //
    clsThreshold.def("getPolarity", &Threshold::getPolarity);
    clsThreshold.def("setPolarity", &Threshold::setPolarity);
    clsThreshold.def("getIncludeMultiplier", &Threshold::getIncludeMultiplier);
    clsThreshold.def("setIncludeMultiplier", &Threshold::setIncludeMultiplier);

    /* Module level */
    mod.def("createThreshold", createThreshold, "value"_a, "type"_a = "value", "polarity"_a = true);
}

PYBIND11_MODULE() [2/9]

lsst::afw::detection::PYBIND11_MODULE	(	footprintMerge	,
		mod
	)

Definition at line 36 of file footprintMerge.cc.

                                     {
    py::class_<FootprintMergeList> clsFootprintMergeList(mod, "FootprintMergeList");

    /* Constructors */
    clsFootprintMergeList.def(
            py::init<afw::table::Schema &, std::vector<std::string> const &, afw::table::Schema const &>(),
            "sourceSchema"_a, "filterList"_a, "initialPeakSchema"_a);
    clsFootprintMergeList.def(py::init<afw::table::Schema &, std::vector<std::string> const &>(),
                              "sourceSchema"_a, "filterList"_a);

    /* Members */
    clsFootprintMergeList.def("getPeakSchema", &FootprintMergeList::getPeakSchema);
    clsFootprintMergeList.def("addCatalog", &FootprintMergeList::addCatalog, "sourceTable"_a, "inputCat"_a,
                              "filter"_a, "minNewPeakDist"_a = -1., "doMerge"_a = true,
                              "maxSamePeakDist"_a = -1.);
    clsFootprintMergeList.def("clearCatalog", &FootprintMergeList::clearCatalog);
    clsFootprintMergeList.def("getFinalSources", &FootprintMergeList::getFinalSources, "outputCat"_a);
}

PYBIND11_MODULE() [3/9]

lsst::afw::detection::PYBIND11_MODULE	(	footprintCtrl	,
		mod
	)

Definition at line 37 of file footprintCtrl.cc.

                                    {
    py::class_<FootprintControl> clsFootprintControl(mod, "FootprintControl");

    /* Constructors */
    clsFootprintControl.def(py::init<>());
    clsFootprintControl.def(py::init<bool, bool>(), "circular"_a, "isotropic"_a = false);
    clsFootprintControl.def(py::init<bool, bool, bool, bool>(), "left"_a, "right"_a, "up"_a, "down"_a);

    /* Members */
    clsFootprintControl.def("growCircular", &FootprintControl::growCircular);
    clsFootprintControl.def("growIsotropic", &FootprintControl::growIsotropic);
    clsFootprintControl.def("growLeft", &FootprintControl::growLeft);
    clsFootprintControl.def("growRight", &FootprintControl::growRight);
    clsFootprintControl.def("growUp", &FootprintControl::growUp);
    clsFootprintControl.def("growDown", &FootprintControl::growDown);

    clsFootprintControl.def("isCircular", &FootprintControl::isCircular);
    clsFootprintControl.def("isIsotropic", &FootprintControl::isIsotropic);
    clsFootprintControl.def("isLeft", &FootprintControl::isLeft);
    clsFootprintControl.def("isRight", &FootprintControl::isRight);
    clsFootprintControl.def("isUp", &FootprintControl::isUp);
    clsFootprintControl.def("isDown", &FootprintControl::isDown);

    py::class_<HeavyFootprintCtrl> clsHeavyFootprintCtrl(mod, "HeavyFootprintCtrl");

    py::enum_<HeavyFootprintCtrl::ModifySource>(clsHeavyFootprintCtrl, "ModifySource")
            .value("NONE", HeavyFootprintCtrl::ModifySource::NONE)
            .value("SET", HeavyFootprintCtrl::ModifySource::SET)
            .export_values();

    clsHeavyFootprintCtrl.def(py::init<HeavyFootprintCtrl::ModifySource>(),
                              "modifySource"_a = HeavyFootprintCtrl::ModifySource::NONE);

    clsHeavyFootprintCtrl.def("getModifySource", &HeavyFootprintCtrl::getModifySource);
    clsHeavyFootprintCtrl.def("setModifySource", &HeavyFootprintCtrl::setModifySource);
    clsHeavyFootprintCtrl.def("getImageVal", &HeavyFootprintCtrl::getImageVal);
    clsHeavyFootprintCtrl.def("setImageVal", &HeavyFootprintCtrl::setImageVal);
    clsHeavyFootprintCtrl.def("getMaskVal", &HeavyFootprintCtrl::getMaskVal);
    clsHeavyFootprintCtrl.def("setMaskVal", &HeavyFootprintCtrl::setMaskVal);
    clsHeavyFootprintCtrl.def("getVarianceVal", &HeavyFootprintCtrl::getVarianceVal);
    clsHeavyFootprintCtrl.def("setVarianceVal", &HeavyFootprintCtrl::setVarianceVal);

    /* Module level */

    /* Member types and enums */
}

PYBIND11_MODULE() [4/9]

lsst::afw::detection::PYBIND11_MODULE	(	gaussianPsf	,
		mod
	)

Definition at line 37 of file gaussianPsf.cc.

                                  {
    py::class_<GaussianPsf, std::shared_ptr<GaussianPsf>, Psf> clsGaussianPsf(mod, "GaussianPsf");

    table::io::python::addPersistableMethods<GaussianPsf>(clsGaussianPsf);    

    /* Constructors */
    clsGaussianPsf.def(py::init<int, int, double>(), "width"_a, "height"_a, "sigma"_a);
    clsGaussianPsf.def(py::init<lsst::geom::Extent2I const &, double>(), "dimensions"_a, "sigma"_a);

    /* Members */
    clsGaussianPsf.def("clone", &GaussianPsf::clone);
    clsGaussianPsf.def("resized", &GaussianPsf::resized, "width"_a, "height"_a);
    clsGaussianPsf.def("getDimensions", &GaussianPsf::getDimensions);
    clsGaussianPsf.def("getSigma", &GaussianPsf::getSigma);
    clsGaussianPsf.def("isPersistable", &GaussianPsf::isPersistable);
}

PYBIND11_MODULE() [5/9]

lsst::afw::detection::PYBIND11_MODULE	(	psf	,
		mod
	)

Definition at line 45 of file psf.cc.

                          {
    /* Module level */
    py::class_<Psf, std::shared_ptr<Psf>, daf::base::Citizen> cls(mod, "Psf");

    /* Member types and enums */
    py::enum_<Psf::ImageOwnerEnum>(cls, "ImageOwnerEnum")
            .value("COPY", Psf::ImageOwnerEnum::COPY)
            .value("INTERNAL", Psf::ImageOwnerEnum::INTERNAL)
            .export_values();

    table::io::python::addPersistableMethods<Psf>(cls);

    /* Members */
    cls.def("clone", &Psf::clone);
    cls.def("resized", &Psf::resized, "width"_a, "height"_a);
    cls.def("computeImage", &Psf::computeImage, "position"_a = NullPoint, "color"_a = image::Color(),
            "owner"_a = Psf::ImageOwnerEnum::COPY);
    cls.def("computeKernelImage", &Psf::computeKernelImage, "position"_a = NullPoint,
            "color"_a = image::Color(), "owner"_a = Psf::ImageOwnerEnum::COPY);
    cls.def("computePeak", &Psf::computePeak, "position"_a = NullPoint, "color"_a = image::Color());
    cls.def("computeApertureFlux", &Psf::computeApertureFlux, "radius"_a, "position"_a = NullPoint,
            "color"_a = image::Color());
    cls.def("computeShape", &Psf::computeShape, "position"_a = NullPoint, "color"_a = image::Color());
    cls.def("computeBBox", &Psf::computeBBox, "position"_a = NullPoint, "color"_a = image::Color());
    cls.def("getLocalKernel", &Psf::getLocalKernel, "position"_a = NullPoint, "color"_a = image::Color());
    cls.def("getAverageColor", &Psf::getAverageColor);
    cls.def("getAveragePosition", &Psf::getAveragePosition);
    cls.def_static("recenterKernelImage", &Psf::recenterKernelImage, "im"_a, "position"_a,
                   "warpAlgorithm"_a = "lanczos5", "warpBuffer"_a = 5);
    cls.def("getCacheCapacity", &Psf::getCacheCapacity);
    cls.def("setCacheCapacity", &Psf::setCacheCapacity);
}

PYBIND11_MODULE() [6/9]

lsst::afw::detection::PYBIND11_MODULE	(	footprint	,
		mod
	)

Definition at line 69 of file footprint.cc.

                                {
    /* Footprint Constructors */
    py::class_<Footprint, std::shared_ptr<Footprint>, daf::base::Citizen> clsFootprint(mod, "Footprint");
    clsFootprint.def(py::init<std::shared_ptr<geom::SpanSet>, lsst::geom::Box2I const &>(), "inputSpans"_a,
                     "region"_a = lsst::geom::Box2I());

    clsFootprint.def(
            py::init<std::shared_ptr<geom::SpanSet>, afw::table::Schema const &, lsst::geom::Box2I const &>(),
            "inputSpans"_a, "peakSchema"_a, "region"_a = lsst::geom::Box2I());
    clsFootprint.def(py::init<Footprint const &>());
    clsFootprint.def(py::init<>());

    table::io::python::addPersistableMethods<Footprint>(clsFootprint);

    /* Footprint Methods */
    clsFootprint.def("getSpans", &Footprint::getSpans);
    clsFootprint.def("setSpans", &Footprint::setSpans);
    clsFootprint.def("getPeaks", (PeakCatalog & (Footprint::*)()) & Footprint::getPeaks,
                     py::return_value_policy::reference_internal);
    clsFootprint.def("addPeak", &Footprint::addPeak);
    clsFootprint.def("sortPeaks", &Footprint::sortPeaks, "key"_a = afw::table::Key<float>());
    clsFootprint.def("setPeakSchema", &Footprint::setPeakSchema);
    clsFootprint.def("setPeakCatalog", &Footprint::setPeakCatalog, "otherPeaks"_a);
    clsFootprint.def("getArea", &Footprint::getArea);
    clsFootprint.def("getCentroid", &Footprint::getCentroid);
    clsFootprint.def("getShape", &Footprint::getShape);
    clsFootprint.def("shift", (void (Footprint::*)(int, int)) & Footprint::shift);
    clsFootprint.def("shift", (void (Footprint::*)(lsst::geom::ExtentI const &)) & Footprint::shift);
    clsFootprint.def("getBBox", &Footprint::getBBox);
    clsFootprint.def("getRegion", &Footprint::getRegion);
    clsFootprint.def("setRegion", &Footprint::setRegion);
    clsFootprint.def("clipTo", &Footprint::clipTo);
    clsFootprint.def("contains", &Footprint::contains);
    clsFootprint.def("transform", (std::shared_ptr<Footprint> (Footprint::*)(
                                          std::shared_ptr<geom::SkyWcs>, std::shared_ptr<geom::SkyWcs>,
                                          lsst::geom::Box2I const &, bool) const) &
                                          Footprint::transform,
                     "source"_a, "target"_a, "region"_a, "doClip"_a = true);
    clsFootprint.def("transform", (std::shared_ptr<Footprint> (Footprint::*)(
                                          lsst::geom::LinearTransform const &, lsst::geom::Box2I const &, bool) const) &
                                          Footprint::transform);
    clsFootprint.def("transform", (std::shared_ptr<Footprint> (Footprint::*)(
                                          lsst::geom::AffineTransform const &, lsst::geom::Box2I const &, bool) const) &
                                          Footprint::transform);
    clsFootprint.def("transform",
                     (std::shared_ptr<Footprint>(Footprint::*)(geom::TransformPoint2ToPoint2 const &,
                                                               lsst::geom::Box2I const &, bool) const) &
                             Footprint::transform);
    clsFootprint.def("dilate", (void (Footprint::*)(int, geom::Stencil)) & Footprint::dilate, "r"_a,
                     "stencil"_a = geom::Stencil::CIRCLE);
    clsFootprint.def("dilate", (void (Footprint::*)(geom::SpanSet const &)) & Footprint::dilate);
    clsFootprint.def("erode", (void (Footprint::*)(int, geom::Stencil)) & Footprint::erode, "r"_a,
                     "stencil"_a = geom::Stencil::CIRCLE);
    clsFootprint.def("erode", (void (Footprint::*)(geom::SpanSet const &)) & Footprint::erode);
    clsFootprint.def("removeOrphanPeaks", &Footprint::removeOrphanPeaks);
    clsFootprint.def("isContiguous", &Footprint::isContiguous);
    clsFootprint.def("isHeavy", &Footprint::isHeavy);
    clsFootprint.def("assign", (Footprint & (Footprint::*)(Footprint const &)) & Footprint::operator=);
    clsFootprint.def("split", [](Footprint const &self) -> py::list {
        // This is a work around for pybind not properly
        // handling converting a vector of unique pointers
        // to python lists of shared pointers
        py::list l;
        for (auto &ptr : self.split()) {
            l.append(py::cast(std::shared_ptr<Footprint>(std::move(ptr))));
        }
        return l;
    });

    /* Define python level properties */
    clsFootprint.def_property("spans", &Footprint::getSpans, &Footprint::setSpans);
    clsFootprint.def_property_readonly("peaks", (PeakCatalog & (Footprint::*)()) & Footprint::getPeaks,
                                       py::return_value_policy::reference);

    /* Python Operators functions */
    clsFootprint.def("__contains__", [](Footprint const &self, lsst::geom::Point2I const &point) -> bool {
        return self.contains(point);
    });
    clsFootprint.def("__eq__",
                     [](Footprint const &self, Footprint const &other) -> bool { return self == other; },
                     py::is_operator());

    declareMaskFromFootprintList<lsst::afw::image::MaskPixel>(mod);

    mod.def("mergeFootprints", &mergeFootprints);
    mod.def("footprintToBBoxList", &footprintToBBoxList);
}

PYBIND11_MODULE() [7/9]

lsst::afw::detection::PYBIND11_MODULE	(	footprintSet	,
		mod
	)

Definition at line 80 of file footprintSet.cc.

                                   {
    py::module::import("lsst.afw.detection.footprint");

    py::class_<FootprintSet, std::shared_ptr<FootprintSet>, lsst::daf::base::Citizen> clsFootprintSet(
            mod, "FootprintSet");

    declareTemplatedMembers<std::uint16_t>(clsFootprintSet);
    declareTemplatedMembers<int>(clsFootprintSet);
    declareTemplatedMembers<float>(clsFootprintSet);
    declareTemplatedMembers<double>(clsFootprintSet);

    clsFootprintSet.def(py::init<image::Mask<image::MaskPixel> const &, Threshold const &, int const>(),
                        "img"_a, "threshold"_a, "npixMin"_a = 1);

    /* Members */
    clsFootprintSet.def(py::init<lsst::geom::Box2I>(), "region"_a);
    clsFootprintSet.def(py::init<FootprintSet const &>(), "set"_a);
    clsFootprintSet.def(py::init<FootprintSet const &, int, FootprintControl const &>(), "set"_a, "rGrow"_a,
                        "ctrl"_a);
    clsFootprintSet.def(py::init<FootprintSet const &, int, bool>(), "set"_a, "rGrow"_a, "isotropic"_a);
    clsFootprintSet.def(py::init<FootprintSet const &, FootprintSet const &, bool>(), "footprints1"_a,
                        "footprints2"_a, "includePeaks"_a);

    clsFootprintSet.def("swap", &FootprintSet::swap);
    // setFootprints takes shared_ptr<FootprintList> and getFootprints returns it,
    // but pybind11 can't handle that type, so use a custom getter and setter
    clsFootprintSet.def("setFootprints", [](FootprintSet &self, FootprintSet::FootprintList footList) {
        self.setFootprints(std::make_shared<FootprintSet::FootprintList>(std::move(footList)));
    });
    clsFootprintSet.def("getFootprints", [](FootprintSet &self) { return *(self.getFootprints()); });
    clsFootprintSet.def("makeSources", &FootprintSet::makeSources);
    clsFootprintSet.def("setRegion", &FootprintSet::setRegion);
    clsFootprintSet.def("getRegion", &FootprintSet::getRegion);
    clsFootprintSet.def("insertIntoImage", &FootprintSet::insertIntoImage);
    clsFootprintSet.def("setMask", (void (FootprintSet::*)(image::Mask<lsst::afw::image::MaskPixel> *,
                                                           std::string const &)) &
                                           FootprintSet::setMask<lsst::afw::image::MaskPixel>);
    clsFootprintSet.def("setMask",
                        (void (FootprintSet::*)(std::shared_ptr<image::Mask<lsst::afw::image::MaskPixel>>,
                                                std::string const &)) &
                                FootprintSet::setMask<lsst::afw::image::MaskPixel>);
    clsFootprintSet.def("merge", &FootprintSet::merge, "rhs"_a, "tGrow"_a = 0, "rGrow"_a = 0,
                        "isotropic"_a = true);

    /* Module level */

    /* Member types and enums */
}

PYBIND11_MODULE() [8/9]

lsst::afw::detection::PYBIND11_MODULE	(	heavyFootprint	,
		mod
	)

Definition at line 84 of file heavyFootprint.cc.

                                     {
    declareHeavyFootprint<int>(mod, "I");
    declareHeavyFootprint<std::uint16_t>(mod, "U");
    declareHeavyFootprint<float>(mod, "F");
    declareHeavyFootprint<double>(mod, "D");
}

PYBIND11_MODULE() [9/9]

lsst::afw::detection::PYBIND11_MODULE	(	peak	,
		mod
	)

Definition at line 102 of file peak.cc.

                           {
    /* Module level */
    PyPeakRecord clsPeakRecord(mod, "PeakRecord");
    PyPeakTable clsPeakTable(mod, "PeakTable");

    /* Members */
    declarePeakRecord(clsPeakRecord);
    declarePeakTable(clsPeakTable);
    auto clsPeakColumnView = table::python::declareColumnView<PeakRecord>(mod, "Peak");
    auto clsPeakCatalog = table::python::declareCatalog<PeakRecord>(mod, "Peak");

    clsPeakRecord.attr("Table") = clsPeakTable;
    clsPeakRecord.attr("ColumnView") = clsPeakColumnView;
    clsPeakRecord.attr("Catalog") = clsPeakCatalog;
    clsPeakTable.attr("Record") = clsPeakRecord;
    clsPeakTable.attr("ColumnView") = clsPeakColumnView;
    clsPeakTable.attr("Catalog") = clsPeakCatalog;
    clsPeakCatalog.attr("Record") = clsPeakRecord;
    clsPeakCatalog.attr("Table") = clsPeakTable;
    clsPeakCatalog.attr("ColumnView") = clsPeakColumnView;
}

resolve_alias()

int lsst::afw::detection::resolve_alias	(	const std::vector< int > &	aliases,
		int	id
	)

Follow a chain of aliases, returning the final resolved value.

Definition at line 96 of file CR.cc.

                          {                        /* alias to look up */
    int resolved = id;                             /* resolved alias */

    while (id != aliases[id]) {
        resolved = id = aliases[id];
    }

    return (resolved);
}