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
_endpoint.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 <ostream>
25 #include <memory>
26 #include <string>
27 
28 #include <type_traits>
29 
30 #include "pybind11/pybind11.h"
31 #include <lsst/utils/python.h>
32 #include "pybind11/stl.h"
33 #include "ndarray/pybind11.h"
34 
35 #include "lsst/geom/Point.h"
36 #include "lsst/geom/SpherePoint.h"
37 #include "lsst/afw/geom/Endpoint.h"
38 
39 namespace py = pybind11;
40 using namespace py::literals;
41 
42 namespace lsst {
43 namespace afw {
44 namespace geom {
45 namespace {
46 
47 /*
48 Add `__str__`, `__repr__` and `getClassPrefix` methods to an Endpoint pybind11 wrapper
49 
50 str(self) = "GenericEndpoint(_nAxes_)" for GenericEndpoint, e.g. "GenericEndpoint(4)";
51  "_typeName_()" for all other Endpoint classes, e.g. "SpherePointEndpoint()",
52 repr(self) = "lsst.afw.geom." + str(self), e.g. "lsst.afw.geom.GenericEndpoint(4)"
53 */
54 template <typename PyClass>
55 void addStrAndRepr(PyClass &cls) {
56  using Class = typename PyClass::type; // C++ class associated with pybind11 wrapper class
57  utils::python::addOutputOp(cls, "__str__");
58  cls.def("__repr__", [](Class const &self) {
60  os << "lsst.afw.geom." << self;
61  return os.str();
62  });
63  cls.def_static("getClassPrefix", &Class::getClassPrefix);
64 }
65 
66 /*
67 Add getNPoints, dataFromPoint, dataFromArray, pointFromData and arrayFromData
68 */
69 template <typename PyClass>
70 void addDataConverters(PyClass &cls) {
71  using Class = typename PyClass::type; // C++ class associated with pybind11 wrapper class
72  cls.def("getNPoints", &Class::getNPoints);
73  cls.def("dataFromPoint", &Class::dataFromPoint);
74  cls.def("dataFromArray", &Class::dataFromArray);
75  cls.def("arrayFromData", &Class::arrayFromData);
76  cls.def("pointFromData", &Class::pointFromData);
77 }
78 
79 /*
80 Add makeFrame method
81 */
82 template <typename PyClass>
83 void addMakeFrame(PyClass &cls) {
84  using Class = typename PyClass::type; // C++ class associated with pybind11 wrapper class
85  // return a deep copy so Python cannot modify the internal state
86  cls.def("makeFrame", [](Class const &self) {
87  auto frame = self.makeFrame();
88  return frame->copy();
89  });
90 }
91 
92 // Allow Python classes to be compared across different BaseEndpoints
93 template <typename SelfClass, typename OtherClass, typename PyClass>
94 std::enable_if_t<std::is_base_of<SelfClass, OtherClass>::value> addEquals(PyClass &cls) {
95  cls.def("__eq__", &SelfClass::operator==);
96  cls.def("__ne__", &SelfClass::operator!=);
97 }
98 
99 template <typename SelfClass, typename OtherClass, typename PyClass>
100 std::enable_if_t<!std::is_base_of<SelfClass, OtherClass>::value> addEquals(PyClass &cls) {
101  cls.def("__eq__", [](SelfClass const &self, OtherClass const &other) { return false; });
102  cls.def("__ne__", [](SelfClass const &self, OtherClass const &other) { return true; });
103 }
104 
105 template <typename SelfClass, typename PyClass>
106 void addAllEquals(PyClass &cls) {
107  addEquals<SelfClass, GenericEndpoint>(cls);
108  addEquals<SelfClass, Point2Endpoint>(cls);
109  addEquals<SelfClass, SpherePointEndpoint>(cls);
110 }
111 
112 /*
113  * Declare BaseVectorEndpoint<Point, Array>;
114  * this is meant to be called by other `declare...` functions;
115  */
116 template <typename Point, typename Array>
117 void declareBaseEndpoint(lsst::utils::python::WrapperCollection &wrappers, std::string const &suffix) {
118  using Class = BaseEndpoint<Point, Array>;
119  std::string const pyClassName = "_BaseEndpoint" + suffix;
120  wrappers.wrapType(py::class_<Class, std::shared_ptr<Class>>(wrappers.module, pyClassName.c_str()),
121  [](auto &mod, auto &cls) {
122  cls.def_property_readonly("nAxes", &Class::getNAxes);
123  addDataConverters(cls);
124  addMakeFrame(cls);
125  cls.def("normalizeFrame", &Class::normalizeFrame);
126  addAllEquals<Class>(cls);
127  });
128 }
129 
130 // Declare BaseVectorEndpoint and all subclasses (the corresponding BaseEndpoint)
131 // This is meant to be called by other `declare...` functions;
132 template <typename Point>
133 void declareBaseVectorEndpoint(lsst::utils::python::WrapperCollection &wrappers, std::string const &suffix) {
134  using Class = BaseVectorEndpoint<Point>;
135  using Array = typename Class::Array;
136 
137  std::string const pyClassName = "_BaseVectorEndpoint" + suffix;
138 
139  declareBaseEndpoint<Point, Array>(wrappers, suffix);
140  wrappers.wrapType(py::class_<Class, std::shared_ptr<Class>, BaseEndpoint<Point, Array>>(
141  wrappers.module, pyClassName.c_str()),
142  [](auto &mod, auto &cls) { addDataConverters(cls); });
143 }
144 
145 // Declare GenericEndpoint and all subclasses
146 void declareGenericEndpoint(lsst::utils::python::WrapperCollection &wrappers) {
147  using Class = GenericEndpoint;
148  using Point = typename Class::Point;
149  using Array = typename Class::Array;
150 
151  declareBaseEndpoint<Point, Array>(wrappers, "Generic");
152 
153  wrappers.wrapType(py::class_<Class, std::shared_ptr<Class>, BaseEndpoint<Point, Array>>(
154  wrappers.module, "GenericEndpoint"),
155  [](auto &mod, auto &cls) {
156  cls.def(py::init<int>(), "nAxes"_a);
157 
158  addStrAndRepr(cls);
159  });
160 }
161 
163 void declarePoint2Endpoint(lsst::utils::python::WrapperCollection &wrappers) {
164  using Class = Point2Endpoint;
165  using Point = typename Class::Point;
166  std::string const pointNumStr = "Point2";
167  std::string const pyClassName = pointNumStr + "Endpoint";
168 
169  declareBaseVectorEndpoint<Point>(wrappers, pointNumStr);
170 
171  wrappers.wrapType(py::class_<Class, std::shared_ptr<Class>, BaseVectorEndpoint<Point>>(
172  wrappers.module, pyClassName.c_str()),
173  [](auto &mod, auto &cls) {
174  cls.def(py::init<>());
175  // do not wrap the constructor that takes nAxes; it is an implementation detail
176 
177  cls.def("normalizeFrame", &Class::normalizeFrame);
178  addStrAndRepr(cls);
179  });
180 }
181 
183 void declareSpherePointEndpoint(lsst::utils::python::WrapperCollection &wrappers) {
184  using Class = SpherePointEndpoint;
185  using Point = typename Class::Point;
186 
187  declareBaseVectorEndpoint<Point>(wrappers, "SpherePoint");
188 
189  wrappers.wrapType(py::class_<Class, std::shared_ptr<Class>, BaseVectorEndpoint<Point>>(
190  wrappers.module, "SpherePointEndpoint"),
191  [](auto &mod, auto &cls) {
192  cls.def(py::init<>());
193  // do not wrap the constructor that takes nAxes; it is an implementation detail
194 
195  addMakeFrame(cls);
196  cls.def("normalizeFrame", &Class::normalizeFrame);
197  addStrAndRepr(cls);
198  });
199 }
200 } // namespace
201 void wrapEndpoint(lsst::utils::python::WrapperCollection &wrappers) {
202  wrappers.addSignatureDependency("lsst.geom");
203  declareGenericEndpoint(wrappers);
204  declarePoint2Endpoint(wrappers);
205  declareSpherePointEndpoint(wrappers);
206 }
207 
208 } // namespace geom
209 } // namespace afw
210 } // namespace lsst
table::Key< int > type
Definition: Detector.cc:163
std::ostream * os
Definition: Schema.cc:557
T c_str(T... args)
void wrapEndpoint(lsst::utils::python::WrapperCollection &wrappers)
Definition: _endpoint.cc:201
py::class_< PixelAreaBoundedField, std::shared_ptr< PixelAreaBoundedField >, BoundedField > PyClass
void addOutputOp(PyClass &cls, std::string const &method)
Add __str__ or __repr__ method implemented by operator<<.
Definition: python.h:87
A base class for image defects.