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
_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"
38
39namespace py = pybind11;
40using namespace py::literals;
41
42namespace lsst {
43namespace afw {
44namespace geom {
45namespace {
46
47/*
48Add `__str__`, `__repr__` and `getClassPrefix` methods to an Endpoint pybind11 wrapper
49
50str(self) = "GenericEndpoint(_nAxes_)" for GenericEndpoint, e.g. "GenericEndpoint(4)";
51 "_typeName_()" for all other Endpoint classes, e.g. "SpherePointEndpoint()",
52repr(self) = "lsst.afw.geom." + str(self), e.g. "lsst.afw.geom.GenericEndpoint(4)"
53*/
54template <typename PyClass>
55void 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/*
67Add getNPoints, dataFromPoint, dataFromArray, pointFromData and arrayFromData
68*/
69template <typename PyClass>
70void 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/*
80Add makeFrame method
81*/
82template <typename PyClass>
83void 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
93template <typename SelfClass, typename OtherClass, typename PyClass>
94std::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
99template <typename SelfClass, typename OtherClass, typename PyClass>
100std::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
105template <typename SelfClass, typename PyClass>
106void 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 */
116template <typename Point, typename Array>
117void 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;
132template <typename Point>
133void 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
146void 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
163void 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
183void 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
201void 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
std::ostream * os
Definition Schema.cc:557
T c_str(T... args)
void wrapEndpoint(lsst::utils::python::WrapperCollection &wrappers)
Definition _endpoint.cc:201