LSSTApplications  20.0.0
LSSTDataManagementBasePackage
_footprintSet.cc
Go to the documentation of this file.
1 /*
2  * This file is part of afw.
3  *
4  * Developed for the LSST Data Management System.
5  * This product includes software developed by the LSST Project
6  * (https://www.lsst.org).
7  * See the COPYRIGHT file at the top-level directory of this distribution
8  * for details of code ownership.
9  *
10  * This program is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program. If not, see <https://www.gnu.org/licenses/>.
22  */
23 
24 #include <pybind11/pybind11.h>
25 #include <pybind11/stl.h>
26 
27 #include "lsst/utils/python.h"
28 
30 
31 namespace py = pybind11;
32 using namespace py::literals;
33 
34 namespace lsst {
35 namespace afw {
36 namespace detection {
37 
38 namespace {
39 
40 template <typename PixelT, typename PyClass>
41 void declareMakeHeavy(PyClass &cls) {
42  // cls.def("makeHeavy", [](FootprintSet & self, image::MaskedImage<PixelT, image::MaskPixel> const&
43  // mimg) {
44  // return self.makeHeavy(mimg);
45  // });
46  // cls.def("makeHeavy", [](FootprintSet & self, image::MaskedImage<PixelT, image::MaskPixel> const&
47  // mimg, HeavyFootprintCtrl const* ctrl) {
48  // return self.makeHeavy(mimg, ctrl);
49  // });
50  cls.def("makeHeavy",
51  (void (FootprintSet::*)(image::MaskedImage<PixelT, image::MaskPixel> const &,
52  HeavyFootprintCtrl const *)) &
53  FootprintSet::makeHeavy<PixelT, image::MaskPixel>,
54  "mimg"_a, "ctrl"_a = nullptr);
55 }
56 
57 template <typename PixelT, typename PyClass>
58 void declareSetMask(PyClass &cls) {
59  cls.def("setMask",
60  (void (FootprintSet::*)(image::Mask<PixelT> *, std::string const &)) &
61  FootprintSet::setMask<PixelT>,
62  "mask"_a, "planeName"_a);
63 }
64 
65 template <typename PixelT, typename PyClass>
66 void declareTemplatedMembers(PyClass &cls) {
67  /* Constructors */
68  cls.def(py::init<image::Image<PixelT> const &, Threshold const &, int const, bool const>(), "img"_a,
69  "threshold"_a, "npixMin"_a = 1, "setPeaks"_a = true);
70  cls.def(py::init<image::MaskedImage<PixelT, image::MaskPixel> const &, Threshold const &,
71  std::string const &, int const, bool const>(),
72  "img"_a, "threshold"_a, "planeName"_a = "", "npixMin"_a = 1, "setPeaks"_a = true);
73 
74  /* Members */
75  declareMakeHeavy<int>(cls);
76  declareMakeHeavy<float>(cls);
77  declareMakeHeavy<double>(cls);
78  declareMakeHeavy<std::uint16_t>(cls);
79  // declareMakeHeavy<std::uint64_t>(cls);
80  declareSetMask<image::MaskPixel>(cls);
81 }
82 } // namespace
83 
85  wrappers.addSignatureDependency("lsst.afw.image");
86  wrappers.addSignatureDependency("lsst.afw.table");
87 
88  wrappers.wrapType(
89  py::class_<FootprintSet, std::shared_ptr<FootprintSet>>(wrappers.module, "FootprintSet"),
90  [](auto &mod, auto &cls) {
91  declareTemplatedMembers<std::uint16_t>(cls);
92  declareTemplatedMembers<int>(cls);
93  declareTemplatedMembers<float>(cls);
94  declareTemplatedMembers<double>(cls);
95 
96  cls.def(py::init<image::Mask<image::MaskPixel> const &, Threshold const &, int const>(),
97  "img"_a, "threshold"_a, "npixMin"_a = 1);
98 
99  cls.def(py::init<lsst::geom::Box2I>(), "region"_a);
100  cls.def(py::init<FootprintSet const &>(), "set"_a);
101  cls.def(py::init<FootprintSet const &, int, FootprintControl const &>(), "set"_a, "rGrow"_a,
102  "ctrl"_a);
103  cls.def(py::init<FootprintSet const &, int, bool>(), "set"_a, "rGrow"_a, "isotropic"_a);
104  cls.def(py::init<FootprintSet const &, FootprintSet const &, bool>(), "footprints1"_a,
105  "footprints2"_a, "includePeaks"_a);
106 
107  cls.def("swap", &FootprintSet::swap);
108  // setFootprints takes shared_ptr<FootprintList> and getFootprints returns it,
109  // but pybind11 can't handle that type, so use a custom getter and setter
110  cls.def("setFootprints", [](FootprintSet &self, FootprintSet::FootprintList footList) {
111  self.setFootprints(std::make_shared<FootprintSet::FootprintList>(std::move(footList)));
112  });
113  cls.def("getFootprints", [](FootprintSet &self) { return *(self.getFootprints()); });
114  cls.def("makeSources", &FootprintSet::makeSources);
115  cls.def("setRegion", &FootprintSet::setRegion);
116  cls.def("getRegion", &FootprintSet::getRegion);
117  cls.def("insertIntoImage", &FootprintSet::insertIntoImage);
118  cls.def("setMask", (void (FootprintSet::*)(image::Mask<lsst::afw::image::MaskPixel> *,
119  std::string const &)) &
120  FootprintSet::setMask<lsst::afw::image::MaskPixel>);
121  cls.def("setMask",
123  std::string const &)) &
124  FootprintSet::setMask<lsst::afw::image::MaskPixel>);
125  cls.def("merge", &FootprintSet::merge, "rhs"_a, "tGrow"_a = 0, "rGrow"_a = 0,
126  "isotropic"_a = true);
127  });
128 }
129 
130 } // namespace detection
131 } // namespace afw
132 } // namespace lsst
std::string
STL class.
std::shared_ptr
STL class.
lsst::afw::image::Mask
Represent a 2-dimensional array of bitmask pixels.
Definition: Mask.h:77
lsst::afw
Definition: imageAlgorithm.dox:1
lsst::utils::python::WrapperCollection::addSignatureDependency
void addSignatureDependency(std::string const &name)
Indicate an external module that provides a type used in function/method signatures.
Definition: python.h:357
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
lsst::afw::detection::FootprintSet
A set of Footprints, associated with a MaskedImage.
Definition: FootprintSet.h:53
lsst::afw::image::MaskedImage
A class to manipulate images, masks, and variance as a single object.
Definition: MaskedImage.h:73
lsst::utils::python::WrapperCollection::wrapType
PyType wrapType(PyType cls, ClassWrapperCallback function, bool setModuleName=true)
Add a type (class or enum) wrapper, deferring method and other attribute definitions until finish() i...
Definition: python.h:391
FootprintSet.h
PyClass
py::class_< ProductBoundedField, std::shared_ptr< ProductBoundedField >, BoundedField > PyClass
Definition: productBoundedField.cc:32
lsst::utils::python::WrapperCollection
A helper class for subdividing pybind11 module across multiple translation units (i....
Definition: python.h:242
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
python.h
pybind11
Definition: _GenericMap.cc:40
lsst::afw::detection::wrapFootprintSet
void wrapFootprintSet(WrapperCollection &)
Definition: _footprintSet.cc:84
lsst::utils::python::WrapperCollection::module
pybind11::module module
The module object passed to the PYBIND11_MODULE block that contains this WrapperCollection.
Definition: python.h:448
lsst::afw::image::Image
A class to represent a 2-dimensional array of pixels.
Definition: Image.h:58
lsst::utils.tests.init
def init()
Definition: tests.py:58