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
_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("getMetadata", &ExposureInfo::getMetadata);
155  cls.def("setMetadata", &ExposureInfo::setMetadata, "metadata"_a);
156 
157  cls.attr("KEY_PSF") = ExposureInfo::KEY_PSF.getId();
158  cls.def("hasPsf", &ExposureInfo::hasPsf);
159  cls.def("getPsf", &ExposureInfo::getPsf);
160  cls.def(
161  "setPsf",
162  [](ExposureInfo &self, py::object psf) {
163  if (psf.is(py::none())) {
164  self.setPsf(nullptr);
165  } else {
166  self.setPsf(py::cast<std::shared_ptr<afw::detection::Psf>>(psf));
167  }
168  },
169  "psf"_a);
170 
171  cls.attr("KEY_VALID_POLYGON") = ExposureInfo::KEY_VALID_POLYGON.getId();
172  cls.def("hasValidPolygon", &ExposureInfo::hasValidPolygon);
173  cls.def("getValidPolygon", &ExposureInfo::getValidPolygon);
174  cls.def(
175  "setValidPolygon",
176  [](ExposureInfo &self, py::object polygon) {
177  if (polygon.is(py::none())) {
178  self.setValidPolygon(nullptr);
179  } else {
180  self.setValidPolygon(py::cast<std::shared_ptr<afw::geom::polygon::Polygon>>(polygon));
181  }
182  },
183  "polygon"_a);
184 
185  cls.attr("KEY_AP_CORR_MAP") = ExposureInfo::KEY_AP_CORR_MAP.getId();
186  cls.def("hasApCorrMap", &ExposureInfo::hasApCorrMap);
187  cls.def("getApCorrMap", (std::shared_ptr<ApCorrMap>(ExposureInfo::*)()) & ExposureInfo::getApCorrMap);
188  cls.def("setApCorrMap", &ExposureInfo::setApCorrMap, "apCorrMap"_a);
189  cls.def("initApCorrMap", &ExposureInfo::initApCorrMap);
190 
191  cls.attr("KEY_COADD_INPUTS") = ExposureInfo::KEY_COADD_INPUTS.getId();
192  cls.def("hasCoaddInputs", &ExposureInfo::hasCoaddInputs);
193  cls.def("getCoaddInputs", &ExposureInfo::getCoaddInputs);
194  cls.def("setCoaddInputs", &ExposureInfo::setCoaddInputs, "coaddInputs"_a);
195 
196  cls.def("hasVisitInfo", &ExposureInfo::hasVisitInfo);
197  cls.def("getVisitInfo", &ExposureInfo::getVisitInfo);
198  cls.def("setVisitInfo", &ExposureInfo::setVisitInfo, "visitInfo"_a);
199 
200  cls.attr("KEY_TRANSMISSION_CURVE") = ExposureInfo::KEY_TRANSMISSION_CURVE.getId();
201  cls.def("hasTransmissionCurve", &ExposureInfo::hasTransmissionCurve);
202  cls.def("getTransmissionCurve", &ExposureInfo::getTransmissionCurve);
203  cls.def("setTransmissionCurve", &ExposureInfo::setTransmissionCurve, "transmissionCurve"_a);
204  });
205 }
206 } // namespace
207 void wrapExposureInfo(lsst::utils::python::WrapperCollection &wrappers) {
208  wrappers.addSignatureDependency("lsst.daf.base");
209  wrappers.addSignatureDependency("lsst.afw.geom");
210  wrappers.addSignatureDependency("lsst.afw.cameraGeom");
211  wrappers.addSignatureDependency("lsst.afw.detection"); // For Psf
212  declareExposureInfo(wrappers);
213 }
214 } // namespace image
215 } // namespace afw
216 } // namespace lsst
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