LSST Applications 27.0.0,g0265f82a02+469cd937ee,g02d81e74bb+21ad69e7e1,g1470d8bcf6+cbe83ee85a,g2079a07aa2+e67c6346a6,g212a7c68fe+04a9158687,g2305ad1205+94392ce272,g295015adf3+81dd352a9d,g2bbee38e9b+469cd937ee,g337abbeb29+469cd937ee,g3939d97d7f+72a9f7b576,g487adcacf7+71499e7cba,g50ff169b8f+5929b3527e,g52b1c1532d+a6fc98d2e7,g591dd9f2cf+df404f777f,g5a732f18d5+be83d3ecdb,g64a986408d+21ad69e7e1,g858d7b2824+21ad69e7e1,g8a8a8dda67+a6fc98d2e7,g99cad8db69+f62e5b0af5,g9ddcbc5298+d4bad12328,ga1e77700b3+9c366c4306,ga8c6da7877+71e4819109,gb0e22166c9+25ba2f69a1,gb6a65358fc+469cd937ee,gbb8dafda3b+69d3c0e320,gc07e1c2157+a98bf949bb,gc120e1dc64+615ec43309,gc28159a63d+469cd937ee,gcf0d15dbbd+72a9f7b576,gdaeeff99f8+a38ce5ea23,ge6526c86ff+3a7c1ac5f1,ge79ae78c31+469cd937ee,gee10cc3b42+a6fc98d2e7,gf1cff7945b+21ad69e7e1,gfbcc870c63+9a11dc8c8f
LSST Data Management Base Package
Loading...
Searching...
No Matches
_spatialCell.cc
Go to the documentation of this file.
1/*
2 * LSST Data Management System
3 * Copyright 2008-2016 AURA/LSST.
4 *
5 * This product includes software developed by the
6 * LSST Project (http://www.lsst.org/).
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the LSST License Statement and
19 * the GNU General Public License along with this program. If not,
20 * see <https://www.lsstcorp.org/LegalNotices/>.
21 */
22
23#include <memory>
24#include <vector>
25
26#include <pybind11/pybind11.h>
27#include <lsst/utils/python.h>
28#include <pybind11/stl.h>
29
30#include "lsst/geom/Box.h"
31#include "lsst/afw/image.h"
33
34namespace py = pybind11;
35using namespace pybind11::literals;
36
37namespace lsst {
38namespace afw {
39namespace math {
40
41namespace {
42
44
45// Wrap SpatialCellCandidate (an abstract class so no constructor is wrapped)
46void declareSpatialCellCandidate(lsst::utils::python::WrapperCollection &wrappers) {
47 using PyClass = py::class_<SpatialCellCandidate, std::shared_ptr<SpatialCellCandidate>>;
48 auto clsSpatialCellCandidate =
49 wrappers.wrapType(PyClass(wrappers.module, "SpatialCellCandidate"), [](auto &mod, auto &cls) {
50 cls.def("getXCenter", &SpatialCellCandidate::getXCenter);
51 cls.def("getYCenter", &SpatialCellCandidate::getYCenter);
52 cls.def("instantiate", &SpatialCellCandidate::instantiate);
53 cls.def("getCandidateRating", &SpatialCellCandidate::getCandidateRating);
54 cls.def("setCandidateRating", &SpatialCellCandidate::setCandidateRating);
55 cls.def("getId", &SpatialCellCandidate::getId);
56 cls.def("getStatus", &SpatialCellCandidate::getStatus);
57 cls.def("setStatus", &SpatialCellCandidate::setStatus);
58 cls.def("isBad", &SpatialCellCandidate::isBad);
59 });
60 wrappers.wrapType(py::enum_<SpatialCellCandidate::Status>(clsSpatialCellCandidate, "Status"),
61 [](auto &mod, auto &enm) {
62 enm.value("BAD", SpatialCellCandidate::Status::BAD);
63 enm.value("GOOD", SpatialCellCandidate::Status::GOOD);
64 enm.value("UNKNOWN", SpatialCellCandidate::Status::UNKNOWN);
65 enm.export_values();
66 });
67}
68
69// Wrap SpatialCellCandidateIterator
70void declareSpatialCellCandidateIterator(lsst::utils::python::WrapperCollection &wrappers) {
71 wrappers.wrapType(
72 py::class_<SpatialCellCandidateIterator>(wrappers.module, "SpatialCellCandidateIterator"),
73 [](auto &mod, auto &cls) {
74 cls.def("__incr__", &SpatialCellCandidateIterator::operator++, py::is_operator());
75 cls.def(
76 "__deref__",
77 [](SpatialCellCandidateIterator &it) -> std::shared_ptr<SpatialCellCandidate> {
78 return *it;
79 },
80 py::is_operator());
81 cls.def("__eq__", &SpatialCellCandidateIterator::operator==, py::is_operator());
82 cls.def("__ne__", &SpatialCellCandidateIterator::operator!=, py::is_operator());
83 cls.def("__sub__", &SpatialCellCandidateIterator::operator-, py::is_operator());
84 });
85}
86
87// Wrap SpatialCell
88void declareSpatialCell(lsst::utils::python::WrapperCollection &wrappers) {
89 wrappers.wrapType(
90 py::class_<SpatialCell, std::shared_ptr<SpatialCell>>(wrappers.module, "SpatialCell"),
91 [](auto &mod, auto &cls) {
92 cls.def(py::init<std::string const &, lsst::geom::Box2I const &, CandidateList const &>(),
93 "label"_a, "bbox"_a = lsst::geom::Box2I(), "candidateList"_a = CandidateList());
94
95 cls.def("empty", &SpatialCell::empty);
96 cls.def("size", &SpatialCell::size);
97 cls.def("__len__", &SpatialCell::size);
98 cls.def("getLabel", &SpatialCell::getLabel);
99 cls.def("begin", (SpatialCellCandidateIterator(SpatialCell::*)()) & SpatialCell::begin);
100 cls.def("begin", (SpatialCellCandidateIterator(SpatialCell::*)(bool)) & SpatialCell::begin);
101 cls.def("end", (SpatialCellCandidateIterator(SpatialCell::*)()) & SpatialCell::end);
102 cls.def("end", (SpatialCellCandidateIterator(SpatialCell::*)(bool)) & SpatialCell::end);
103 cls.def("insertCandidate", &SpatialCell::insertCandidate);
104 cls.def("removeCandidate", &SpatialCell::removeCandidate);
105 cls.def("setIgnoreBad", &SpatialCell::setIgnoreBad, "ignoreBad"_a);
106 cls.def("getIgnoreBad", &SpatialCell::getIgnoreBad);
107 cls.def("getCandidateById", &SpatialCell::getCandidateById, "id"_a, "noThrow"_a = false);
108 cls.def("getLabel", &SpatialCell::getLabel);
109 cls.def("getBBox", &SpatialCell::getBBox);
110 cls.def("sortCandidates", &SpatialCell::sortCandidates);
111 cls.def("visitCandidates",
112 (void (SpatialCell::*)(CandidateVisitor *, int const, bool const, bool const)) &
113 SpatialCell::visitCandidates,
114 "visitor"_a, "nMaxPerCell"_a = -1, "ignoreExceptions"_a = false, "reset"_a = true);
115 cls.def("visitAllCandidates",
116 (void (SpatialCell::*)(CandidateVisitor *, bool const, bool const)) &
117 SpatialCell::visitAllCandidates,
118 "visitor"_a, "ignoreExceptions"_a = false, "reset"_a = true);
119 });
120}
121
122// Wrap SpatialCellSet
123void declareSpatialCellSet(lsst::utils::python::WrapperCollection &wrappers) {
124 wrappers.wrapType(
125 py::class_<SpatialCellSet, std::shared_ptr<SpatialCellSet>>(wrappers.module, "SpatialCellSet"),
126 [](auto &mod, auto &cls) {
127 cls.def(py::init<lsst::geom::Box2I const &, int, int>(), "region"_a, "xSize"_a,
128 "ySize"_a = 0);
129
130 cls.def("getCellList", &SpatialCellSet::getCellList);
131 cls.def("getBBox", &SpatialCellSet::getBBox);
132 cls.def("insertCandidate", &SpatialCellSet::insertCandidate);
133 cls.def("sortCandidates", &SpatialCellSet::sortCandidates);
134 cls.def("visitCandidates",
135 (void (SpatialCellSet::*)(CandidateVisitor *, int const, bool const)) &
136 SpatialCellSet::visitCandidates,
137 "visitor"_a, "nMaxPerCell"_a = -1, "ignoreExceptions"_a = false);
138 cls.def("visitAllCandidates",
139 (void (SpatialCellSet::*)(CandidateVisitor *, bool const)) &
140 SpatialCellSet::visitAllCandidates,
141 "visitor"_a, "ignoreExceptions"_a = false);
142 cls.def("getCandidateById", &SpatialCellSet::getCandidateById, "id"_a, "noThrow"_a = false);
143 cls.def("setIgnoreBad", &SpatialCellSet::setIgnoreBad, "ignoreBad"_a);
144 });
145}
146
147// Wrap CandidateVisitor
148void declareCandidateVisitor(lsst::utils::python::WrapperCollection &wrappers) {
149 wrappers.wrapType(py::class_<CandidateVisitor, std::shared_ptr<CandidateVisitor>>(wrappers.module,
150 "CandidateVisitor"),
151 [](auto &mod, auto &cls) {
152 cls.def(py::init<>());
153
154 cls.def("reset", &CandidateVisitor::reset);
155 cls.def("processCandidate", &CandidateVisitor::processCandidate);
156 });
157}
158
159// Wrap class SpatialCellImageCandidate (an abstract class, so no constructor is wrapped)
160void declareSpatialCellImageCandidate(lsst::utils::python::WrapperCollection &wrappers) {
161 wrappers.wrapType(py::class_<SpatialCellImageCandidate, std::shared_ptr<SpatialCellImageCandidate>,
162 SpatialCellCandidate>(wrappers.module, "SpatialCellImageCandidate"),
163 [](auto &mod, auto &cls) {
164 cls.def_static("setWidth", &SpatialCellImageCandidate::setWidth, "width"_a);
165 cls.def_static("getWidth", &SpatialCellImageCandidate::getWidth);
166 cls.def_static("setHeight", &SpatialCellImageCandidate::setHeight, "height"_a);
167 cls.def_static("getHeight", &SpatialCellImageCandidate::getHeight);
168 cls.def("setChi2", &SpatialCellImageCandidate::setChi2, "chi2"_a);
169 cls.def("getChi2", &SpatialCellImageCandidate::getChi2);
170 });
171}
172
173void declareTestClasses(lsst::utils::python::WrapperCollection &wrappers) {
174 /*
175 * Test class for SpatialCellCandidate
176 */
177 class TestCandidate : public SpatialCellCandidate {
178 public:
179 TestCandidate(float const xCenter,
180 float const yCenter,
181 float const flux
182 )
183 : SpatialCellCandidate(xCenter, yCenter), _flux(flux) {}
184
186 double getCandidateRating() const override { return _flux; }
187 void setCandidateRating(double flux) override { _flux = flux; }
188
189 private:
190 double _flux;
191 };
192
194 class TestCandidateVisitor : public CandidateVisitor {
195 public:
196 TestCandidateVisitor() : CandidateVisitor() {}
197
198 // Called by SpatialCellSet::visitCandidates before visiting any Candidates
199 void reset() override { _n = 0; }
200
201 // Called by SpatialCellSet::visitCandidates for each Candidate
202 void processCandidate(SpatialCellCandidate *candidate) override { ++_n; }
203
204 int getN() const { return _n; }
205
206 private:
207 int _n{0}; // number of TestCandidates
208 };
209
210 class TestImageCandidate : public SpatialCellImageCandidate {
211 public:
212 using MaskedImageT = image::MaskedImage<float>;
213
214 TestImageCandidate(float const xCenter,
215 float const yCenter,
216 float const flux
217 )
218 : SpatialCellImageCandidate(xCenter, yCenter), _flux(flux) {}
219
221 double getCandidateRating() const override { return _flux; }
222
224 std::shared_ptr<MaskedImageT const> getMaskedImage() const {
225 if (!_image) {
226 _image = std::make_shared<MaskedImageT>(lsst::geom::ExtentI(getWidth(), getHeight()));
227 *_image->getImage() = _flux;
228 }
229 return _image;
230 }
231
232 private:
233 mutable std::shared_ptr<MaskedImageT> _image;
234 double _flux;
235 };
236
237 wrappers.wrapType(py::class_<TestCandidate, std::shared_ptr<TestCandidate>, SpatialCellCandidate>(
238 wrappers.module, "TestCandidate"),
239 [](auto &mod, auto &cls) {
240 cls.def(py::init<float const, float const, float const>());
241 cls.def("getCandidateRating", &TestCandidate::getCandidateRating);
242 cls.def("setCandidateRating", &TestCandidate::setCandidateRating);
243 });
244 wrappers.wrapType(
245 py::class_<TestCandidateVisitor, std::shared_ptr<TestCandidateVisitor>, CandidateVisitor>(
246 wrappers.module, "TestCandidateVisitor"),
247 [](auto &mod, auto &cls) {
248 cls.def(py::init<>());
249 cls.def("getN", &TestCandidateVisitor::getN);
250 });
251 wrappers.wrapType(
252 py::class_<TestImageCandidate, std::shared_ptr<TestImageCandidate>, SpatialCellImageCandidate>(
253 wrappers.module, "TestImageCandidate"),
254 [](auto &mod, auto &cls) {
255 cls.def(py::init<float const, float const, float const>(), "xCenter"_a, "yCenter"_a,
256 "flux"_a);
257 cls.def("getCandidateRating", &TestImageCandidate::getCandidateRating);
258 cls.def("getMaskedImage", &TestImageCandidate::getMaskedImage);
259 });
260};
261} // namespace
262void wrapSpatialCell(lsst::utils::python::WrapperCollection &wrappers) {
263 declareSpatialCellCandidate(wrappers);
264 declareSpatialCellCandidateIterator(wrappers);
265 declareSpatialCell(wrappers);
266 declareSpatialCellSet(wrappers);
267 declareCandidateVisitor(wrappers);
268 declareSpatialCellImageCandidate(wrappers);
269 /* Test Members */
270 declareTestClasses(wrappers);
271}
272} // namespace math
273} // namespace afw
274} // namespace lsst
A class to manipulate images, masks, and variance as a single object.
Definition MaskedImage.h:74
py::class_< PixelAreaBoundedField, std::shared_ptr< PixelAreaBoundedField >, BoundedField > PyClass
void wrapSpatialCell(lsst::utils::python::WrapperCollection &)