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
_detector.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 <memory>
25#include <string>
26
27#include "pybind11/pybind11.h"
28#include <lsst/utils/python.h>
29
30#include "pybind11/stl.h"
31
32#include "ndarray/pybind11.h"
33
34#include "lsst/utils/python.h"
37#include "lsst/geom.h"
42
43namespace py = pybind11;
44using namespace py::literals;
45
46namespace lsst {
47namespace afw {
48namespace cameraGeom {
49
50namespace {
51
52using PyDetectorBase = py::class_<DetectorBase, std::shared_ptr<DetectorBase>>;
53using PyDetector = py::class_<Detector, DetectorBase, std::shared_ptr<Detector>, typehandling::Storable>;
54using PyDetectorBuilder = py::class_<Detector::Builder, DetectorBase, std::shared_ptr<Detector::Builder>>;
55using PyDetectorPartialRebuilder = py::class_<Detector::PartialRebuilder, Detector::Builder,
57using PyDetectorInCameraBuilder =
58 py::class_<Detector::InCameraBuilder, Detector::Builder, std::shared_ptr<Detector::InCameraBuilder>>;
59
60// Declare Detector methods overloaded on one coordinate system class
61template <typename SysT, typename PyClass>
62void declare1SysMethods(PyClass &cls) {
63 cls.def("getCorners",
64 (std::vector<lsst::geom::Point2D>(Detector::*)(SysT const &) const) & Detector::getCorners,
65 "cameraSys"_a);
66 cls.def("getCenter", (lsst::geom::Point2D(Detector::*)(SysT const &) const) & Detector::getCenter,
67 "cameraSys"_a);
68 cls.def("hasTransform", (bool (Detector::*)(SysT const &) const) & Detector::hasTransform, "cameraSys"_a);
69}
70
71// Declare Detector methods templated on two coordinate system classes
72template <typename FromSysT, typename ToSysT, typename PyClass>
73void declare2SysMethods(PyClass &cls) {
74 cls.def("getTransform",
75 (std::shared_ptr<geom::TransformPoint2ToPoint2>(Detector::*)(FromSysT const &, ToSysT const &)
76 const) &
77 Detector::getTransform,
78 "fromSys"_a, "toSys"_a);
79 cls.def("transform",
80 (lsst::geom::Point2D(Detector::*)(lsst::geom::Point2D const &, FromSysT const &, ToSysT const &)
81 const) &
82 Detector::transform,
83 "point"_a, "fromSys"_a, "toSys"_a);
84 cls.def("transform",
85 (std::vector<lsst::geom::Point2D>(Detector::*)(std::vector<lsst::geom::Point2D> const &,
86 FromSysT const &, ToSysT const &) const) &
87 Detector::transform,
88 "points"_a, "fromSys"_a, "toSys"_a);
89}
90
91void declareDetectorBase(lsst::utils::python::WrapperCollection &wrappers) {
92 wrappers.wrapType(PyDetectorBase(wrappers.module, "DetectorBase"), [](auto &mod, auto &cls) {
93 cls.def("getName", &DetectorBase::getName);
94 cls.def("getId", &DetectorBase::getId);
95 cls.def("getType", &DetectorBase::getType);
96 cls.def("getPhysicalType", &DetectorBase::getPhysicalType);
97 cls.def("getSerial", &DetectorBase::getSerial);
98 cls.def("getBBox", &DetectorBase::getBBox);
99 cls.def("getOrientation", &DetectorBase::getOrientation);
100 cls.def("getPixelSize", &DetectorBase::getPixelSize);
101 cls.def("hasCrosstalk", &DetectorBase::hasCrosstalk);
102 cls.def("getCrosstalk", &DetectorBase::getCrosstalk);
103 cls.def("getNativeCoordSys", &DetectorBase::getNativeCoordSys);
104 cls.def("makeCameraSys",
105 py::overload_cast<CameraSys const &>(&DetectorBase::makeCameraSys, py::const_),
106 "cameraSys"_a);
107 cls.def("makeCameraSys",
108 py::overload_cast<CameraSysPrefix const &>(&DetectorBase::makeCameraSys, py::const_),
109 "cameraSysPrefix"_a);
110 });
111}
112
113void declareDetectorBuilder(PyDetector &parent);
114void declareDetectorPartialRebuilder(PyDetector &parent);
115void declareDetectorInCameraBuilder(PyDetector &parent);
116
117void declareDetector(lsst::utils::python::WrapperCollection &wrappers) {
118 wrappers.wrapType(PyDetector(wrappers.module, "Detector"), [](auto &mod, auto &cls) {
119 declareDetectorBuilder(cls);
120 declareDetectorPartialRebuilder(cls);
121 declareDetectorInCameraBuilder(cls);
122 cls.def("rebuild", &Detector::rebuild);
123 declare1SysMethods<CameraSys>(cls);
124 declare1SysMethods<CameraSysPrefix>(cls);
125 declare2SysMethods<CameraSys, CameraSys>(cls);
126 declare2SysMethods<CameraSys, CameraSysPrefix>(cls);
127 declare2SysMethods<CameraSysPrefix, CameraSys>(cls);
128 declare2SysMethods<CameraSysPrefix, CameraSysPrefix>(cls);
129 cls.def("getTransformMap", &Detector::getTransformMap);
130 cls.def("getAmplifiers", &Detector::getAmplifiers);
131 // __iter__ defined in pure-Python extension
132 cls.def(
133 "__getitem__",
134 [](Detector const &self, std::ptrdiff_t i) {
135 return self[utils::python::cppIndex(self.size(), i)];
136 },
137 "i"_a);
138 cls.def("__getitem__", py::overload_cast<std::string const &>(&Detector::operator[], py::const_),
139 "name"_a);
140 cls.def("__len__", &Detector::size);
142 });
143}
144
145void declareDetectorBuilder(PyDetector &parent) {
146 PyDetectorBuilder cls(parent, "Builder");
147 cls.def("setBBox", &Detector::Builder::setBBox);
148 cls.def("setType", &Detector::Builder::setType);
149 cls.def("setSerial", &Detector::Builder::setSerial);
150 cls.def("setPhysicalType", &Detector::Builder::setPhysicalType);
151 cls.def("setCrosstalk", &Detector::Builder::setCrosstalk);
152 cls.def("unsetCrosstalk", &Detector::Builder::unsetCrosstalk);
153 cls.def("getAmplifiers", &Detector::Builder::getAmplifiers);
154 cls.def(
155 "__getitem__",
156 [](Detector::Builder const &self, std::ptrdiff_t i) {
157 return self[utils::python::cppIndex(self.size(), i)];
158 },
159 "i"_a);
160 cls.def("__getitem__", py::overload_cast<std::string const &>(&Detector::Builder::operator[], py::const_),
161 "name"_a);
162 cls.def("append", &Detector::Builder::append);
163 cls.def("clear", &Detector::Builder::clear);
164 cls.def("__len__", &Detector::Builder::size);
165}
166
167void declareDetectorPartialRebuilder(PyDetector &parent) {
168 PyDetectorPartialRebuilder cls(parent, "PartialRebuilder");
169 cls.def(py::init<Detector const &>(), "detector"_a);
170 cls.def("finish", &Detector::PartialRebuilder::finish);
171}
172
173void declareDetectorInCameraBuilder(PyDetector &parent) {
174 PyDetectorInCameraBuilder cls(parent, "InCameraBuilder");
175 cls.def("setOrientation", &Detector::InCameraBuilder::setOrientation);
176 cls.def("setPixelSize", &Detector::InCameraBuilder::setPixelSize);
177 cls.def("setTransformFromPixelsTo",
178 py::overload_cast<CameraSysPrefix const &,
181 "toSys"_a, "transform"_a);
182 cls.def("setTransformFromPixelsTo",
183 py::overload_cast<CameraSys const &, std::shared_ptr<afw::geom::TransformPoint2ToPoint2 const>>(
185 "toSys"_a, "transform"_a);
186 cls.def("discardTransformFromPixelsTo",
187 py::overload_cast<CameraSysPrefix const &>(
189 "toSys"_a);
190 cls.def("discardTransformFromPixelsTo",
191 py::overload_cast<CameraSys const &>(&Detector::InCameraBuilder::discardTransformFromPixelsTo),
192 "toSys"_a);
193}
194} // namespace
195void wrapDetector(lsst::utils::python::WrapperCollection &wrappers) {
196 wrappers.addInheritanceDependency("lsst.afw.typehandling");
197 wrappers.wrapType(py::enum_<DetectorType>(wrappers.module, "DetectorType"), [](auto &mod, auto &enm) {
198 enm.value("SCIENCE", DetectorType::SCIENCE);
199 enm.value("FOCUS", DetectorType::FOCUS);
200 enm.value("GUIDER", DetectorType::GUIDER);
201 enm.value("WAVEFRONT", DetectorType::WAVEFRONT);
202 });
203 declareDetectorBase(wrappers);
204 declareDetector(wrappers);
205}
206} // namespace cameraGeom
207} // namespace afw
208} // namespace lsst
void setSerial(std::string const &serial)
Set the detector serial "number".
Definition Detector.h:381
void setBBox(lsst::geom::Box2I const &bbox)
Set the bounding box.
Definition Detector.h:375
void setPhysicalType(std::string const &physicalType)
Set the detector's physical type.
Definition Detector.h:388
void setCrosstalk(CrosstalkMatrix const &crosstalk)
Set the crosstalk coefficients.
Definition Detector.h:400
std::vector< std::shared_ptr< Amplifier::Builder > > const & getAmplifiers() const
Return the sequence of Amplifier::Builders directly.
Definition Detector.h:418
void setType(DetectorType type)
Set the purpose of this detector.
Definition Detector.h:378
void unsetCrosstalk()
Remove the crosstalk coefficient matrix.
Definition Detector.h:403
void append(std::shared_ptr< Amplifier::Builder > builder)
Append a new amplifier.
Definition Detector.cc:376
std::size_t size() const
Return the number of amplifiers (renamed to len in Python).
Definition Detector.h:451
void clear()
Remove all amplifiers.
Definition Detector.h:448
void setOrientation(Orientation const &orientation)
Set the orientation of the detector in the focal plane.
Definition Detector.h:561
void setTransformFromPixelsTo(CameraSysPrefix const &toSys, std::shared_ptr< afw::geom::TransformPoint2ToPoint2 const > transform)
Set the transformation from PIXELS to the given coordinate system.
Definition Detector.cc:438
bool discardTransformFromPixelsTo(CameraSysPrefix const &toSys)
Remove any transformation from PIXELS to the given coordinate system.
Definition Detector.cc:466
void setPixelSize(lsst::geom::Extent2D const &pixelSize)
Set the pixel size (in mm).
Definition Detector.h:566
std::shared_ptr< Detector const > finish() const
Construct a new Detector from the current state of the Builder.
Definition Detector.cc:413
std::size_t size() const
Get the number of amplifiers.
Definition Detector.h:299
void wrapDetector(lsst::utils::python::WrapperCollection &)
Definition _detector.cc:195
void addPersistableMethods(pybind11::class_< Class, Args... > &cls)
Add table::io::Persistable and PersistableFacade methods to the pybind11 wrapper for a class.
Definition python.h:56
Point< double, 2 > Point2D
Definition Point.h:324
STL namespace.