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
_transform.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#include "pybind11/eigen.h"
27
28#include <memory>
29
30#include "astshim.h"
31#include "pybind11/stl.h"
32#include "ndarray/pybind11.h"
33
38
39namespace py = pybind11;
40using namespace py::literals;
41
42namespace lsst {
43namespace afw {
44namespace geom {
45namespace {
46
47// Return a string consisting of "_pythonClassName_[_fromNAxes_->_toNAxes_]",
48// for example "TransformGenericToPoint2[4->2]"
49template <class Class>
50std::string formatStr(Class const &self, std::string const &pyClassName) {
52 os << pyClassName;
53 os << "[" << self.getFromEndpoint().getNAxes() << "->" << self.getToEndpoint().getNAxes() << "]";
54 return os.str();
55}
56
57template <class FromEndpoint, class ToEndpoint, class NextToEndpoint, class PyClass>
58void declareMethodTemplates(PyClass &cls) {
59 using ThisTransform = Transform<FromEndpoint, ToEndpoint>;
60 using NextTransform = Transform<ToEndpoint, NextToEndpoint>;
61 using SeriesTransform = Transform<FromEndpoint, NextToEndpoint>;
62 // Need Python-specific logic to give sensible errors for mismatched Transform types
63 cls.def("_then",
64 (std::shared_ptr<SeriesTransform>(ThisTransform::*)(NextTransform const &, bool) const) &
65 ThisTransform::template then<NextToEndpoint>,
66 "next"_a, "simplify"_a = true);
67}
68
69// Declare Transform<FromEndpoint, ToEndpoint> using python class name Transform<X>To<Y>
70// where <X> and <Y> are the prefix of the from endpoint and to endpoint class, respectively,
71// for example TransformGenericToPoint2
72template <class FromEndpoint, class ToEndpoint>
73void declareTransform(lsst::utils::python::WrapperCollection &wrappers) {
74 using Class = Transform<FromEndpoint, ToEndpoint>;
75 using ToPoint = typename ToEndpoint::Point;
76 using ToArray = typename ToEndpoint::Array;
77 using FromPoint = typename FromEndpoint::Point;
78 using FromArray = typename FromEndpoint::Array;
79
80 std::string const pyClassName = Class::getShortClassName();
81 wrappers.wrapType(
82 py::class_<Class, std::shared_ptr<Class>, table::io::Persistable>(wrappers.module, pyClassName.c_str()),
83 [](auto &mod, auto &cls) {
84 std::string const pyClassName = Class::getShortClassName();
85 cls.def(py::init<ast::FrameSet const &, bool>(), "frameSet"_a, "simplify"_a = true);
86 cls.def(py::init<ast::Mapping const &, bool>(), "mapping"_a, "simplify"_a = true);
87
88 cls.def_property_readonly("hasForward", &Class::hasForward);
89 cls.def_property_readonly("hasInverse", &Class::hasInverse);
90 cls.def_property_readonly("fromEndpoint", &Class::getFromEndpoint);
91 cls.def_property_readonly("toEndpoint", &Class::getToEndpoint);
92
93 // Return a copy of the contained Mapping in order to assure changing the returned Mapping
94 // will not affect the contained Mapping (since Python ignores constness)
95 cls.def("getMapping", [](Class const &self) { return self.getMapping()->copy(); });
96
97 cls.def("applyForward",
98 py::overload_cast<FromArray const &>(&Class::applyForward, py::const_), "array"_a);
99 cls.def("applyForward",
100 py::overload_cast<FromPoint const &>(&Class::applyForward, py::const_), "point"_a);
101 cls.def("applyInverse", py::overload_cast<ToArray const &>(&Class::applyInverse, py::const_),
102 "array"_a);
103 cls.def("applyInverse", py::overload_cast<ToPoint const &>(&Class::applyInverse, py::const_),
104 "point"_a);
105 cls.def("inverted", &Class::inverted);
106 /* Need some extra handling of ndarray return type in Python to prevent dimensions
107 * of length 1 from being deleted */
108 cls.def("_getJacobian", &Class::getJacobian);
109 // Do not wrap getShortClassName because it returns the name of the class;
110 // use `<class>.__name__` or `type(<instance>).__name__` instead.
111 // Do not wrap readStream or writeStream because C++ streams are not easy to wrap.
112 cls.def_static("readString", &Class::readString);
113 cls.def("writeString", &Class::writeString);
114
115 declareMethodTemplates<FromEndpoint, ToEndpoint, GenericEndpoint>(cls);
116 declareMethodTemplates<FromEndpoint, ToEndpoint, Point2Endpoint>(cls);
117 declareMethodTemplates<FromEndpoint, ToEndpoint, SpherePointEndpoint>(cls);
118
119 // str(self) = "<Python class name>[<nIn>-><nOut>]"
120 cls.def("__str__", [pyClassName](Class const &self) { return formatStr(self, pyClassName); });
121 // repr(self) = "lsst.afw.geom.<Python class name>[<nIn>-><nOut>]"
122 cls.def("__repr__", [pyClassName](Class const &self) {
123 return "lsst.afw.geom." + formatStr(self, pyClassName);
124 });
125
126 table::io::python::addPersistableMethods<Class>(cls);
127 });
128}
129} // namespace
130void wrapTransform(lsst::utils::python::WrapperCollection &wrappers) {
131 wrappers.addSignatureDependency("lsst.afw.table.io");
132 wrappers.addSignatureDependency("astshim");
133 declareTransform<GenericEndpoint, GenericEndpoint>(wrappers);
134 declareTransform<GenericEndpoint, Point2Endpoint>(wrappers);
135 declareTransform<GenericEndpoint, SpherePointEndpoint>(wrappers);
136 declareTransform<Point2Endpoint, GenericEndpoint>(wrappers);
137 declareTransform<Point2Endpoint, Point2Endpoint>(wrappers);
138 declareTransform<Point2Endpoint, SpherePointEndpoint>(wrappers);
139 declareTransform<SpherePointEndpoint, GenericEndpoint>(wrappers);
140 declareTransform<SpherePointEndpoint, Point2Endpoint>(wrappers);
141 declareTransform<SpherePointEndpoint, SpherePointEndpoint>(wrappers);
142}
143} // namespace geom
144} // namespace afw
145} // namespace lsst
std::ostream * os
Definition Schema.cc:557
T c_str(T... args)