LSST Applications  21.0.0-147-g0e635eb1+1acddb5be5,22.0.0+052faf71bd,22.0.0+1ea9a8b2b2,22.0.0+6312710a6c,22.0.0+729191ecac,22.0.0+7589c3a021,22.0.0+9f079a9461,22.0.1-1-g7d6de66+b8044ec9de,22.0.1-1-g87000a6+536b1ee016,22.0.1-1-g8e32f31+6312710a6c,22.0.1-10-gd060f87+016f7cdc03,22.0.1-12-g9c3108e+df145f6f68,22.0.1-16-g314fa6d+c825727ab8,22.0.1-19-g93a5c75+d23f2fb6d8,22.0.1-19-gb93eaa13+aab3ef7709,22.0.1-2-g8ef0a89+b8044ec9de,22.0.1-2-g92698f7+9f079a9461,22.0.1-2-ga9b0f51+052faf71bd,22.0.1-2-gac51dbf+052faf71bd,22.0.1-2-gb66926d+6312710a6c,22.0.1-2-gcb770ba+09e3807989,22.0.1-20-g32debb5+b8044ec9de,22.0.1-23-gc2439a9a+fb0756638e,22.0.1-3-g496fd5d+09117f784f,22.0.1-3-g59f966b+1e6ba2c031,22.0.1-3-g849a1b8+f8b568069f,22.0.1-3-gaaec9c0+c5c846a8b1,22.0.1-32-g5ddfab5d3+60ce4897b0,22.0.1-4-g037fbe1+64e601228d,22.0.1-4-g8623105+b8044ec9de,22.0.1-5-g096abc9+d18c45d440,22.0.1-5-g15c806e+57f5c03693,22.0.1-7-gba73697+57f5c03693,master-g6e05de7fdc+c1283a92b8,master-g72cdda8301+729191ecac,w.2021.39
LSST Data Management Base Package
_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 
34 namespace py = pybind11;
35 using namespace pybind11::literals;
36 
37 namespace lsst {
38 namespace afw {
39 namespace math {
40 
41 namespace {
42 
44 
45 // Wrap SpatialCellCandidate (an abstract class so no constructor is wrapped)
46 void 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
70 void 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
88 void 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
123 void 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
148 void 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)
160 void 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 
173 void 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
262 void 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:73
void wrapSpatialCell(lsst::utils::python::WrapperCollection &)
py::class_< PixelAreaBoundedField, std::shared_ptr< PixelAreaBoundedField >, BoundedField > PyClass
A base class for image defects.