lsst::afw::detection Namespace Reference

Namespaces
namespace	_footprintContinued
namespace	_footprintMerge
namespace	_heavyFootprintContinued
namespace	_peak
namespace	detail
namespace	multiband
namespace	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	InvalidPsfError
	An exception thrown when we have an invalid PSF. 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	PsfTrampoline
	"Trampoline" for Psf to let it be used as a base class in Python. More...
class	Threshold
	A Threshold is used to pass a threshold value to detection algorithms. More...

Typedefs
using	FootprintIdPixel = std::uint64_t
	Pixel type for FootprintSet::insertIntoImage()
using	PeakColumnView = afw::table::ColumnViewT<PeakRecord>
using	PeakCatalog = afw::table::CatalogT<PeakRecord>
using	ConstPeakCatalog = afw::table::CatalogT<const PeakRecord>

Functions
std::ostream &	operator<< (std::ostream &os, Footprint const &rhs)
	Print a Footprint to the stream.
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.
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.
std::ostream &	operator<< (std::ostream &os, FootprintSet const &rhs)
	Print a FootprintSet to the stream.
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=nullptr)
	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.
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.
void	wrapFootprint (WrapperCollection &)
void	wrapFootprintCtrl (WrapperCollection &)
void	wrapFootprintMerge (WrapperCollection &)
void	wrapFootprintSet (WrapperCollection &)
void	wrapGaussianPsf (WrapperCollection &)
void	wrapHeavyFootprint (WrapperCollection &)
void	wrapPeak (WrapperCollection &)
void	wrapPsf (WrapperCollection &)
void	wrapThreshold (WrapperCollection &)
	PYBIND11_MODULE (_detection, mod)
int	resolve_alias (const std::vector< int > &aliases, int id)
	Follow a chain of aliases, returning the final resolved value.

Typedef Documentation

ConstPeakCatalog

using lsst::afw::detection::ConstPeakCatalog = afw::table::CatalogT<const PeakRecord>

Definition at line 245 of file Peak.h.

FootprintIdPixel

using lsst::afw::detection::FootprintIdPixel = std::uint64_t

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 50 of file FootprintSet.h.

PeakCatalog

using lsst::afw::detection::PeakCatalog = afw::table::CatalogT<PeakRecord>

Definition at line 244 of file Peak.h.

PeakColumnView

using lsst::afw::detection::PeakColumnView = afw::table::ColumnViewT<PeakRecord>

Definition at line 243 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 366 of file Footprint.cc.

                                                                         {
    using PixelT = std::uint16_t;
    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;
                int const x_size = 1 + x1 - x0;
 
                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(x0, y) + x_size, 0) !=
                        idImage->at(x0, y) + x_size) {
                        break;  // some pixels weren't set, so the BBox stops here, (actually in previous row)
                    }
                    std::fill(idImage->at(x0, y), idImage->at(x0, y) + x_size, 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 = nullptr )

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 341 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 128 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<<() [1/3]

std::ostream & lsst::afw::detection::operator<<	(	std::ostream &	os,
		Footprint const &	rhs )

Print a Footprint to the stream.

Parameters

os	Stream to print to.
rhs	Footprint to print.

Definition at line 443 of file Footprint.cc.

                                                             {
    os << rhs.getPeaks().size() << " peaks, area=" << rhs.getArea() << ", centroid=" << rhs.getCentroid();
    return os;
}

operator<<() [2/3]

std::ostream & lsst::afw::detection::operator<<	(	std::ostream &	os,
		FootprintSet const &	rhs )

Print a FootprintSet to the stream.

Parameters

os	Stream to print to.
rhs	FootprintSet to print.

operator<<() [3/3]

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

Definition at line 91 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()

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

Definition at line 47 of file _detection.cc.

                                 {
    WrapperCollection wrappers(mod, "lsst.afw.detection");
    wrapPsf(wrappers);
    wrapFootprintCtrl(wrappers);
    wrapFootprint(wrappers);
    wrapThreshold(wrappers);
    wrapFootprintSet(wrappers);
    wrapFootprintMerge(wrappers);
    wrapPeak(wrappers);
    wrapGaussianPsf(wrappers);
    wrapHeavyFootprint(wrappers);
    wrappers.finish();
}

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);
}

wrapFootprint()

void lsst::afw::detection::wrapFootprint

(

WrapperCollection &

wrappers

)

Definition at line 77 of file _footprint.cc.

                                                {
    wrappers.addInheritanceDependency("lsst.afw.table.io");
    wrappers.addSignatureDependency("lsst.afw.geom");
    wrappers.addSignatureDependency("lsst.afw.table");
 
    wrappers.wrapType(
            py::class_<Footprint, std::shared_ptr<Footprint>>(wrappers.module, "Footprint"),
            [](auto &mod, auto &cls) {
                cls.def(py::init<std::shared_ptr<geom::SpanSet>, lsst::geom::Box2I const &>(), "inputSpans"_a,
                        "region"_a = lsst::geom::Box2I());
 
                cls.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());
                cls.def(py::init<Footprint const &>());
                cls.def(py::init<>());
 
                table::io::python::addPersistableMethods<Footprint>(cls);
 
                cls.def("getSpans", &Footprint::getSpans);
                cls.def("setSpans", &Footprint::setSpans);
                cls.def("getPeaks", (PeakCatalog & (Footprint::*)()) & Footprint::getPeaks,
                        py::return_value_policy::reference_internal);
                cls.def("addPeak", &Footprint::addPeak);
                cls.def("sortPeaks", &Footprint::sortPeaks, "key"_a = afw::table::Key<float>());
                cls.def("setPeakSchema", &Footprint::setPeakSchema);
                cls.def("setPeakCatalog", &Footprint::setPeakCatalog, "otherPeaks"_a);
                cls.def("getArea", &Footprint::getArea);
                cls.def("getCentroid", &Footprint::getCentroid);
                cls.def("getShape", &Footprint::getShape);
                cls.def("shift", (void (Footprint::*)(int, int)) & Footprint::shift);
                cls.def("shift", (void (Footprint::*)(lsst::geom::ExtentI const &)) & Footprint::shift);
                cls.def("getBBox", &Footprint::getBBox);
                cls.def("getRegion", &Footprint::getRegion);
                cls.def("setRegion", &Footprint::setRegion);
                cls.def("clipTo", &Footprint::clipTo);
                cls.def("contains", &Footprint::contains);
                cls.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);
                cls.def("transform",
                        (std::shared_ptr<Footprint>(Footprint::*)(lsst::geom::LinearTransform const &,
                                                                  lsst::geom::Box2I const &, bool) const) &
                                Footprint::transform);
                cls.def("transform",
                        (std::shared_ptr<Footprint>(Footprint::*)(lsst::geom::AffineTransform const &,
                                                                  lsst::geom::Box2I const &, bool) const) &
                                Footprint::transform);
                cls.def("transform",
                        (std::shared_ptr<Footprint>(Footprint::*)(geom::TransformPoint2ToPoint2 const &,
                                                                  lsst::geom::Box2I const &, bool) const) &
                                Footprint::transform);
                cls.def("dilate", (void (Footprint::*)(int, geom::Stencil)) & Footprint::dilate, "r"_a,
                        "stencil"_a = geom::Stencil::CIRCLE);
                cls.def("dilate", (void (Footprint::*)(geom::SpanSet const &)) & Footprint::dilate);
                cls.def("erode", (void (Footprint::*)(int, geom::Stencil)) & Footprint::erode, "r"_a,
                        "stencil"_a = geom::Stencil::CIRCLE);
                cls.def("erode", (void (Footprint::*)(geom::SpanSet const &)) & Footprint::erode);
                cls.def("removeOrphanPeaks", &Footprint::removeOrphanPeaks);
                cls.def("updatePeakSignificance",
                        py::overload_cast<double>(&Footprint::updatePeakSignificance));
                cls.def("updatePeakSignificance", py::overload_cast<image::Image<float> const &, int>(
                                                          &Footprint::updatePeakSignificance));
                cls.def("isContiguous", &Footprint::isContiguous);
                cls.def("isHeavy", &Footprint::isHeavy);
                cls.def("assign", (Footprint & (Footprint::*)(Footprint const &)) & Footprint::operator=);
 
                cls.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;
                });
 
                cls.def_property("spans", &Footprint::getSpans, &Footprint::setSpans);
                cls.def_property_readonly("peaks", (PeakCatalog & (Footprint::*)()) & Footprint::getPeaks,
                                          py::return_value_policy::reference_internal);
 
                cls.def("__contains__", [](Footprint const &self, lsst::geom::Point2I const &point) -> bool {
                    return self.contains(point);
                });
                cls.def(
                        "__eq__",
                        [](Footprint const &self, Footprint const &other) -> bool { return self == other; },
                        py::is_operator());
                cpputils::python::addOutputOp(cls, "__repr__");
            });
 
    declareMaskFromFootprintList<lsst::afw::image::MaskPixel>(wrappers);
 
    wrappers.wrap([](auto &mod) {
        mod.def("mergeFootprints", &mergeFootprints);
        mod.def("footprintToBBoxList", &footprintToBBoxList);
    });
}

wrapFootprintCtrl()

void lsst::afw::detection::wrapFootprintCtrl

(

WrapperCollection &

wrappers

)

Definition at line 39 of file _footprintCtrl.cc.

                                                                  {
    wrappers.wrapType(py::class_<FootprintControl>(wrappers.module, "FootprintControl"),
                      [](auto& mod, auto& cls) {
                          cls.def(py::init<>());
                          cls.def(py::init<bool, bool>(), "circular"_a, "isotropic"_a = false);
                          cls.def(py::init<bool, bool, bool, bool>(), "left"_a, "right"_a, "up"_a, "down"_a);
 
                          cls.def("growCircular", &FootprintControl::growCircular);
                          cls.def("growIsotropic", &FootprintControl::growIsotropic);
                          cls.def("growLeft", &FootprintControl::growLeft);
                          cls.def("growRight", &FootprintControl::growRight);
                          cls.def("growUp", &FootprintControl::growUp);
                          cls.def("growDown", &FootprintControl::growDown);
 
                          cls.def("isCircular", &FootprintControl::isCircular);
                          cls.def("isIsotropic", &FootprintControl::isIsotropic);
                          cls.def("isLeft", &FootprintControl::isLeft);
                          cls.def("isRight", &FootprintControl::isRight);
                          cls.def("isUp", &FootprintControl::isUp);
                          cls.def("isDown", &FootprintControl::isDown);
                      });
 
    auto clsHeavyFootprintCtrl = wrappers.wrapType(
            py::class_<HeavyFootprintCtrl>(wrappers.module, "HeavyFootprintCtrl"), [](auto& mod, auto& cls) {
                cls.def(py::init<HeavyFootprintCtrl::ModifySource>(),
                        "modifySource"_a = HeavyFootprintCtrl::ModifySource::NONE);
 
                cls.def("getModifySource", &HeavyFootprintCtrl::getModifySource);
                cls.def("setModifySource", &HeavyFootprintCtrl::setModifySource);
                cls.def("getImageVal", &HeavyFootprintCtrl::getImageVal);
                cls.def("setImageVal", &HeavyFootprintCtrl::setImageVal);
                cls.def("getMaskVal", &HeavyFootprintCtrl::getMaskVal);
                cls.def("setMaskVal", &HeavyFootprintCtrl::setMaskVal);
                cls.def("getVarianceVal", &HeavyFootprintCtrl::getVarianceVal);
                cls.def("setVarianceVal", &HeavyFootprintCtrl::setVarianceVal);
            });
 
    wrappers.wrapType(py::enum_<HeavyFootprintCtrl::ModifySource>(clsHeavyFootprintCtrl, "ModifySource"),
                      [](auto& mod, auto& enm) {
                          enm.value("NONE", HeavyFootprintCtrl::ModifySource::NONE);
                          enm.value("SET", HeavyFootprintCtrl::ModifySource::SET);
                          enm.export_values();
                      });
}

wrapFootprintMerge()

void lsst::afw::detection::wrapFootprintMerge

(

WrapperCollection &

wrappers

)

Definition at line 38 of file _footprintMerge.cc.

                                                                   {
    wrappers.addSignatureDependency("lsst.afw.table");
 
    wrappers.wrapType(
            py::class_<FootprintMergeList>(wrappers.module, "FootprintMergeList"), [](auto &mod, auto &cls) {
                cls.def(py::init<afw::table::Schema &, std::vector<std::string> const &,
                                 afw::table::Schema const &>(),
                        "sourceSchema"_a, "filterList"_a, "initialPeakSchema"_a);
                cls.def(py::init<afw::table::Schema &, std::vector<std::string> const &>(), "sourceSchema"_a,
                        "filterList"_a);
 
                cls.def("getPeakSchema", &FootprintMergeList::getPeakSchema);
                cls.def("addCatalog", &FootprintMergeList::addCatalog, "sourceTable"_a, "inputCat"_a,
                        "filter"_a, "minNewPeakDist"_a = -1., "doMerge"_a = true, "maxSamePeakDist"_a = -1.);
                cls.def("clearCatalog", &FootprintMergeList::clearCatalog);
                cls.def("getFinalSources", &FootprintMergeList::getFinalSources, "outputCat"_a);
            });
}

wrapFootprintSet()

void lsst::afw::detection::wrapFootprintSet

(

WrapperCollection &

wrappers

)

Definition at line 86 of file _footprintSet.cc.

                                                                 {
    wrappers.addSignatureDependency("lsst.afw.image");
    wrappers.addSignatureDependency("lsst.afw.table");
 
    wrappers.wrapType(
            py::class_<FootprintSet, std::shared_ptr<FootprintSet>>(wrappers.module, "FootprintSet"),
            [](auto &mod, auto &cls) {
                declareTemplatedMembers<std::uint16_t>(cls);
                declareTemplatedMembers<int>(cls);
                declareTemplatedMembers<float>(cls);
                declareTemplatedMembers<double>(cls);
 
                cls.def(py::init<image::Mask<image::MaskPixel> const &, Threshold const &, int const>(),
                        "img"_a, "threshold"_a, "npixMin"_a = 1);
 
                cls.def(py::init<lsst::geom::Box2I>(), "region"_a);
                cls.def(py::init<FootprintSet const &>(), "set"_a);
                cls.def(py::init<FootprintSet const &, int, FootprintControl const &>(), "set"_a, "rGrow"_a,
                        "ctrl"_a);
                cls.def(py::init<FootprintSet const &, int, bool>(), "set"_a, "rGrow"_a, "isotropic"_a);
                cls.def(py::init<FootprintSet const &, FootprintSet const &, bool>(), "footprints1"_a,
                        "footprints2"_a, "includePeaks"_a);
 
                cls.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
                cls.def("setFootprints", [](FootprintSet &self, FootprintSet::FootprintList footList) {
                    self.setFootprints(std::make_shared<FootprintSet::FootprintList>(std::move(footList)));
                });
                cls.def("getFootprints", [](FootprintSet &self) { return *(self.getFootprints()); });
                cls.def("makeSources", &FootprintSet::makeSources);
                cls.def("setRegion", &FootprintSet::setRegion);
                cls.def("getRegion", &FootprintSet::getRegion);
                cls.def("insertIntoImage", &FootprintSet::insertIntoImage);
                cls.def("setMask", (void (FootprintSet::*)(image::Mask<lsst::afw::image::MaskPixel> *,
                                                           std::string const &)) &
                                           FootprintSet::setMask<lsst::afw::image::MaskPixel>);
                cls.def("setMask",
                        (void (FootprintSet::*)(std::shared_ptr<image::Mask<lsst::afw::image::MaskPixel>>,
                                                std::string const &)) &
                                FootprintSet::setMask<lsst::afw::image::MaskPixel>);
                cls.def("merge", &FootprintSet::merge, "rhs"_a, "tGrow"_a = 0, "rGrow"_a = 0,
                        "isotropic"_a = true);
                cpputils::python::addOutputOp(cls, "__repr__");
            });
}

wrapGaussianPsf()

void lsst::afw::detection::wrapGaussianPsf

(

WrapperCollection &

wrappers

)

Definition at line 38 of file _gaussianPsf.cc.

                                                                {
    wrappers.wrapType(
            py::class_<GaussianPsf, std::shared_ptr<GaussianPsf>, Psf>(wrappers.module, "GaussianPsf"),
            [](auto& mod, auto& cls) {
                table::io::python::addPersistableMethods<GaussianPsf>(cls);
 
                cls.def(py::init<int, int, double>(), "width"_a, "height"_a, "sigma"_a);
                cls.def(py::init<lsst::geom::Extent2I const&, double>(), "dimensions"_a, "sigma"_a);
 
                cls.def("clone", &GaussianPsf::clone);
                cls.def("resized", &GaussianPsf::resized, "width"_a, "height"_a);
                cls.def("getDimensions", &GaussianPsf::getDimensions);
                cls.def("getSigma", &GaussianPsf::getSigma);
                cls.def("isPersistable", &GaussianPsf::isPersistable);
            });
}

wrapHeavyFootprint()

void lsst::afw::detection::wrapHeavyFootprint

(

WrapperCollection &

wrappers

)

Definition at line 88 of file _heavyFootprint.cc.

                                                     {
    wrappers.addSignatureDependency("lsst.afw.image");
 
    declareHeavyFootprint<int>(wrappers, "I");
    declareHeavyFootprint<std::uint16_t>(wrappers, "U");
    declareHeavyFootprint<float>(wrappers, "F");
    declareHeavyFootprint<double>(wrappers, "D");
}

wrapPeak()

void lsst::afw::detection::wrapPeak

(

WrapperCollection &

wrappers

)

Definition at line 101 of file _peak.cc.

                                                         {
    wrappers.addInheritanceDependency("lsst.afw.table");
 
    auto clsPeakRecord = wrappers.wrapType(PyPeakRecord(wrappers.module, "PeakRecord"),
                                           [](auto &mod, auto &cls) { declarePeakRecord(cls); });
    auto clsPeakTable = wrappers.wrapType(PyPeakTable(wrappers.module, "PeakTable"),
                                          [](auto &mod, auto &cls) { declarePeakTable(cls); });
 
    auto clsPeakColumnView = table::python::declareColumnView<PeakRecord>(wrappers, "Peak");
    auto clsPeakCatalog = table::python::declareCatalog<PeakRecord>(wrappers, "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;
}

wrapPsf()

void lsst::afw::detection::wrapPsf

(

WrapperCollection &

wrappers

)

Definition at line 50 of file _psf.cc.

                                                        {
    wrappers.addInheritanceDependency("lsst.afw.typehandling");
    wrappers.addSignatureDependency("lsst.afw.geom.ellipses");
    wrappers.addSignatureDependency("lsst.afw.image");
    wrappers.addSignatureDependency("lsst.afw.fits");
 
    auto cls = wrappers.wrapException<InvalidPsfError, pex::exceptions::InvalidParameterError>("InvalidPsfError",
                                                                                               "InvalidParameterError");
    cls.def(py::init<std::string const &>());
 
    auto clsPsf = wrappers.wrapType(
            py::class_<Psf, PySharedPtr<Psf>, typehandling::Storable, PsfTrampoline<>>(
                wrappers.module, "Psf"
            ),
            [](auto& mod, auto& cls) {
                table::io::python::addPersistableMethods<Psf>(cls);
                cls.def(py::init<bool, size_t>(), "isFixed"_a=false, "capacity"_a=100);  // Constructor for pure-Python subclasses
                cls.def("clone", &Psf::clone);
                cls.def("resized", &Psf::resized, "width"_a, "height"_a);
 
                cls.def("computeImage",
                        &Psf::computeImage,
                        "position"_a,
                        "color"_a = image::Color(),
                        "owner"_a = Psf::ImageOwnerEnum::COPY
                );
                cls.def("computeKernelImage",
                        &Psf::computeKernelImage,
                        "position"_a,
                        "color"_a = image::Color(),
                        "owner"_a = Psf::ImageOwnerEnum::COPY
                );
                cls.def("computePeak",
                        &Psf::computePeak,
                        "position"_a,
                        "color"_a = image::Color()
                );
                cls.def("computeApertureFlux",
                        &Psf::computeApertureFlux,
                        "radius"_a,
                        "position"_a,
                        "color"_a = image::Color()
                );
                cls.def("computeShape",
                        &Psf::computeShape,
                        "position"_a,
                        "color"_a = image::Color()
                );
                cls.def("computeBBox",
                        &Psf::computeBBox,
                        "position"_a,
                        "color"_a = image::Color()
                );
                cls.def("computeImageBBox",
                        &Psf::computeImageBBox,
                        "position"_a,
                        "color"_a = image::Color()
                );
                cls.def("computeKernelBBox",
                        &Psf::computeKernelBBox,
                        "position"_a,
                        "color"_a = image::Color()
                );
                cls.def("getLocalKernel",
                        &Psf::getLocalKernel,
                        "position"_a,
                        "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);
            }
    );
 
    wrappers.wrapType(py::enum_<Psf::ImageOwnerEnum>(clsPsf, "ImageOwnerEnum"), [](auto& mod, auto& enm) {
        enm.value("COPY", Psf::ImageOwnerEnum::COPY);
        enm.value("INTERNAL", Psf::ImageOwnerEnum::INTERNAL);
        enm.export_values();
    });
}

wrapThreshold()

void lsst::afw::detection::wrapThreshold

(

WrapperCollection &

wrappers

)

Definition at line 41 of file _threshold.cc.

                                                              {
    auto clsThreshold = wrappers.wrapType(
            py::class_<Threshold, std::shared_ptr<Threshold>>(wrappers.module, "Threshold"),
            [](auto& mod, auto& cls) {
                cls.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);
 
                cls.def("getType", &Threshold::getType);
                cls.def_static("parseTypeString", Threshold::parseTypeString);
                cls.def_static("getTypeString", Threshold::getTypeString);
                cls.def("getValue", (double (Threshold::*)(const double) const) & Threshold::getValue,
                        "param"_a = -1);
                //
                //    template<typename ImageT>
                //    double getValue(ImageT const& image) const;
                //
                cls.def("getPolarity", &Threshold::getPolarity);
                cls.def("setPolarity", &Threshold::setPolarity);
                cls.def("getIncludeMultiplier", &Threshold::getIncludeMultiplier);
                cls.def("setIncludeMultiplier", &Threshold::setIncludeMultiplier);
                // Different str/repr so that the latter can be used to create a Threshold.
                cls.def("__str__", [](Threshold const& self) {
                    std::ostringstream os;
                    std::string polarity = (self.getPolarity() == true) ? "positive" : "negative";
                    os << py::cast(self.getType()).attr("name").cast<std::string>() << std::setprecision(8)
                       << " value=" << self.getValue(1.0) << " (" << polarity << ")";
                    if (self.getIncludeMultiplier() != 1.0) {
                        os << " multiplier=" << self.getIncludeMultiplier();
                    }
                    return os.str();
                });
                cls.def("__repr__", [](Threshold const& self) {
                    std::ostringstream os;
                    os << std::setprecision(16) << "Threshold(value=" << self.getValue(1.0)
                       << ", type=" << py::cast(self.getType()).attr("name").cast<std::string>()
                       << ", polarity=" << self.getPolarity()
                       << ", includeMultiplier=" << self.getIncludeMultiplier() << ")";
                    return os.str();
                });
            });
 
    wrappers.wrapType(py::enum_<Threshold::ThresholdType>(clsThreshold, "ThresholdType"),
                      [](auto& mod, auto& enm) {
                          enm.value("VALUE", Threshold::ThresholdType::VALUE);
                          enm.value("BITMASK", Threshold::ThresholdType::BITMASK);
                          enm.value("STDEV", Threshold::ThresholdType::STDEV);
                          enm.value("VARIANCE", Threshold::ThresholdType::VARIANCE);
                          enm.value("PIXEL_STDEV", Threshold::ThresholdType::PIXEL_STDEV);
                          enm.export_values();
                      });
 
    wrappers.wrap([](auto& mod) {
        mod.def("createThreshold", createThreshold, "value"_a, "type"_a = "value", "polarity"_a = true);
    });
}