LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
_exposureInfo.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 "lsst/utils/python.h"
26 
29 #include "lsst/afw/detection/Psf.h"
31 #include "lsst/afw/geom/SkyWcs.h"
35 #include "lsst/afw/image/Filter.h"
41 
42 namespace py = pybind11;
43 using namespace py::literals;
44 
45 namespace lsst {
46 namespace afw {
47 namespace image {
48 namespace {
49 
50 using PyExposureInfo = py::class_<ExposureInfo, std::shared_ptr<ExposureInfo>>;
51 
52 // Template methods where we can use pybind11's overload resolution (T is input)
53 template <class T>
54 void declareGenericMethods(PyExposureInfo &cls) {
55  using Class = PyExposureInfo::type;
56  cls.def(
57  "setComponent",
58  [](PyExposureInfo::type &self, std::string const &key, T const &object) {
59  self.setComponent(typehandling::makeKey<T>(key), object);
60  },
61  "key"_a, "object"_a);
62 }
63 // Template methods where we need to provide a unified interface (T is not input)
64 void declareGenericMethodsMerged(PyExposureInfo &cls) {
65  using typehandling::Storable;
66  using Class = PyExposureInfo::type;
67  cls.def(
68  "hasComponent",
69  [](Class const &self, std::string const &key) {
70  return self.hasComponent(typehandling::makeKey<std::shared_ptr<Storable const>>(key));
71  },
72  "key"_a);
73  cls.def(
74  "getComponent",
75  [](Class const &self, std::string const &key) -> py::object {
76  auto sharedKey = typehandling::makeKey<std::shared_ptr<Storable const>>(key);
77  // Cascading if-elses to support other types in the future
78  if (self.hasComponent(sharedKey)) {
79  return py::cast(self.getComponent(sharedKey));
80  } else {
81  return py::none();
82  }
83  },
84  "key"_a);
85  cls.def(
86  "removeComponent",
87  [](Class &self, std::string const &key) {
88  self.removeComponent(typehandling::makeKey<std::shared_ptr<Storable const>>(key));
89  },
90  "key"_a);
91 }
92 
93 void declareExposureInfo(lsst::utils::python::WrapperCollection &wrappers) {
94  wrappers.wrapType(PyExposureInfo(wrappers.module, "ExposureInfo"), [](auto &mod, auto &cls) {
95  /* Constructors */
96  cls.def(py::init<std::shared_ptr<geom::SkyWcs const> const &,
97  std::shared_ptr<detection::Psf const> const &,
98  std::shared_ptr<PhotoCalib const> const &,
99  std::shared_ptr<cameraGeom::Detector const> const &,
100  std::shared_ptr<geom::polygon::Polygon const> const &, Filter const &,
101  std::shared_ptr<daf::base::PropertySet> const &,
102  std::shared_ptr<CoaddInputs> const &, std::shared_ptr<ApCorrMap> const &,
103  std::shared_ptr<VisitInfo const> const &,
104  std::shared_ptr<TransmissionCurve const> const &>(),
105  "wcs"_a = std::shared_ptr<geom::SkyWcs const>(),
106  "psf"_a = std::shared_ptr<detection::Psf const>(),
107  "photoCalib"_a = std::shared_ptr<PhotoCalib const>(),
108  "detector"_a = std::shared_ptr<cameraGeom::Detector const>(),
109  "polygon"_a = std::shared_ptr<geom::polygon::Polygon const>(), "filter"_a = Filter(),
110  "metadata"_a = std::shared_ptr<daf::base::PropertySet>(),
111  "coaddInputs"_a = std::shared_ptr<CoaddInputs>(),
112  "apCorrMap"_a = std::shared_ptr<ApCorrMap>(),
113  "visitInfo"_a = std::shared_ptr<VisitInfo const>(), "transmissionCurve"_a = nullptr);
114  cls.def(py::init<>());
115  cls.def(py::init<ExposureInfo>(), "other"_a);
116  cls.def(py::init<ExposureInfo, bool>(), "other"_a, "copyMetadata"_a);
117 
118  /* Members */
119  cls.attr("KEY_WCS") = ExposureInfo::KEY_WCS.getId();
120  cls.def("hasWcs", &ExposureInfo::hasWcs);
121  cls.def("getWcs", (std::shared_ptr<geom::SkyWcs>(ExposureInfo::*)()) & ExposureInfo::getWcs);
122  cls.def("setWcs", &ExposureInfo::setWcs, "wcs"_a);
123 
124  cls.attr("KEY_DETECTOR") = ExposureInfo::KEY_DETECTOR.getId();
125  cls.def("hasDetector", &ExposureInfo::hasDetector);
126  cls.def("getDetector", &ExposureInfo::getDetector);
127  cls.def(
128  "setDetector",
129  [](ExposureInfo &self, py::object detector) {
130  if (detector.is(py::none())) {
131  self.setDetector(nullptr);
132  } else {
133  self.setDetector(py::cast<std::shared_ptr<afw::cameraGeom::Detector>>(detector));
134  }
135  },
136  "detector"_a);
137 
138  cls.def("getFilter", &ExposureInfo::getFilter);
139  cls.def("setFilter", &ExposureInfo::setFilter, "filter"_a);
140 
141  cls.attr("KEY_FILTER") = ExposureInfo::KEY_FILTER.getId();
142  cls.def("hasFilterLabel", &ExposureInfo::hasFilterLabel);
143  cls.def("getFilterLabel", &ExposureInfo::getFilterLabel);
144  cls.def("setFilterLabel", &ExposureInfo::setFilterLabel, "filterLabel"_a);
145 
146  declareGenericMethods<std::shared_ptr<typehandling::Storable const>>(cls);
147  declareGenericMethodsMerged(cls);
148 
149  cls.attr("KEY_PHOTO_CALIB") = ExposureInfo::KEY_PHOTO_CALIB.getId();
150  cls.def("hasPhotoCalib", &ExposureInfo::hasPhotoCalib);
151  cls.def("getPhotoCalib", &ExposureInfo::getPhotoCalib);
152  cls.def("setPhotoCalib", &ExposureInfo::setPhotoCalib, "photoCalib"_a);
153 
154  cls.def("hasId", &ExposureInfo::hasId);
155  // Use exception handler to avoid overhead of calling hasId twice, and
156  // because asking for a nonexistent ID should be rare.
157  auto getId = [](ExposureInfo const &self) -> py::object {
158  try {
159  return py::cast(self.getId());
160  } catch (pex::exceptions::NotFoundError const &) {
161  return py::none();
162  }
163  };
164  auto setId = [](ExposureInfo &self, py::object id) {
165  if (id.is_none()) {
166  self.clearId();
167  } else {
168  self.setId(id.cast<table::RecordId>());
169  }
170  };
171  cls.def("getId", getId);
172  cls.def("setId", setId, "id"_a);
173  cls.def("clearId", &ExposureInfo::clearId);
174  cls.def_property("id", getId, setId);
175 
176  cls.def("getMetadata", &ExposureInfo::getMetadata);
177  cls.def("setMetadata", &ExposureInfo::setMetadata, "metadata"_a);
178 
179  cls.attr("KEY_PSF") = ExposureInfo::KEY_PSF.getId();
180  cls.def("hasPsf", &ExposureInfo::hasPsf);
181  cls.def("getPsf", &ExposureInfo::getPsf);
182  cls.def(
183  "setPsf",
184  [](ExposureInfo &self, py::object psf) {
185  if (psf.is(py::none())) {
186  self.setPsf(nullptr);
187  } else {
188  self.setPsf(py::cast<std::shared_ptr<afw::detection::Psf>>(psf));
189  }
190  },
191  "psf"_a);
192 
193  cls.attr("KEY_VALID_POLYGON") = ExposureInfo::KEY_VALID_POLYGON.getId();
194  cls.def("hasValidPolygon", &ExposureInfo::hasValidPolygon);
195  cls.def("getValidPolygon", &ExposureInfo::getValidPolygon);
196  cls.def(
197  "setValidPolygon",
198  [](ExposureInfo &self, py::object polygon) {
199  if (polygon.is(py::none())) {
200  self.setValidPolygon(nullptr);
201  } else {
202  self.setValidPolygon(py::cast<std::shared_ptr<afw::geom::polygon::Polygon>>(polygon));
203  }
204  },
205  "polygon"_a);
206 
207  cls.attr("KEY_AP_CORR_MAP") = ExposureInfo::KEY_AP_CORR_MAP.getId();
208  cls.def("hasApCorrMap", &ExposureInfo::hasApCorrMap);
209  cls.def("getApCorrMap", (std::shared_ptr<ApCorrMap>(ExposureInfo::*)()) & ExposureInfo::getApCorrMap);
210  cls.def("setApCorrMap", &ExposureInfo::setApCorrMap, "apCorrMap"_a);
211  cls.def("initApCorrMap", &ExposureInfo::initApCorrMap);
212 
213  cls.attr("KEY_COADD_INPUTS") = ExposureInfo::KEY_COADD_INPUTS.getId();
214  cls.def("hasCoaddInputs", &ExposureInfo::hasCoaddInputs);
215  cls.def("getCoaddInputs", &ExposureInfo::getCoaddInputs);
216  cls.def("setCoaddInputs", &ExposureInfo::setCoaddInputs, "coaddInputs"_a);
217 
218  cls.def("hasVisitInfo", &ExposureInfo::hasVisitInfo);
219  cls.def("getVisitInfo", &ExposureInfo::getVisitInfo);
220  cls.def("setVisitInfo", &ExposureInfo::setVisitInfo, "visitInfo"_a);
221 
222  cls.attr("KEY_TRANSMISSION_CURVE") = ExposureInfo::KEY_TRANSMISSION_CURVE.getId();
223  cls.def("hasTransmissionCurve", &ExposureInfo::hasTransmissionCurve);
224  cls.def("getTransmissionCurve", &ExposureInfo::getTransmissionCurve);
225  cls.def("setTransmissionCurve", &ExposureInfo::setTransmissionCurve, "transmissionCurve"_a);
226  });
227 }
228 } // namespace
229 void wrapExposureInfo(lsst::utils::python::WrapperCollection &wrappers) {
230  wrappers.addSignatureDependency("lsst.daf.base");
231  wrappers.addSignatureDependency("lsst.afw.geom");
232  wrappers.addSignatureDependency("lsst.afw.cameraGeom");
233  wrappers.addSignatureDependency("lsst.afw.detection"); // For Psf
234  declareExposureInfo(wrappers);
235 }
236 } // namespace image
237 } // namespace afw
238 } // namespace lsst
table::Key< int > id
Definition: Detector.cc:162
table::Key< int > type
Definition: Detector.cc:163
Implementation of the Photometric Calibration class.
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.
void wrapExposureInfo(lsst::utils::python::WrapperCollection &wrappers)
constexpr Key< K, V > makeKey(K const &id)
Factory function for Key, to enable type parameter inference.
Definition: Key.h:173
A base class for image defects.
Key< int > psf
Definition: Exposure.cc:65