LSSTApplications  17.0+124,17.0+14,17.0+73,18.0.0+37,18.0.0+80,18.0.0-4-g68ffd23+4,18.1.0-1-g0001055+12,18.1.0-1-g03d53ef+5,18.1.0-1-g1349e88+55,18.1.0-1-g2505f39+44,18.1.0-1-g5315e5e+4,18.1.0-1-g5e4b7ea+14,18.1.0-1-g7e8fceb+4,18.1.0-1-g85f8cd4+48,18.1.0-1-g8ff0b9f+4,18.1.0-1-ga2c679d+1,18.1.0-1-gd55f500+35,18.1.0-10-gb58edde+2,18.1.0-11-g0997b02+4,18.1.0-13-gfe4edf0b+12,18.1.0-14-g259bd21+21,18.1.0-19-gdb69f3f+2,18.1.0-2-g5f9922c+24,18.1.0-2-gd3b74e5+11,18.1.0-2-gfbf3545+32,18.1.0-26-g728bddb4+5,18.1.0-27-g6ff7ca9+2,18.1.0-3-g52aa583+25,18.1.0-3-g8ea57af+9,18.1.0-3-gb69f684+42,18.1.0-3-gfcaddf3+6,18.1.0-32-gd8786685a,18.1.0-4-gf3f9b77+6,18.1.0-5-g1dd662b+2,18.1.0-5-g6dbcb01+41,18.1.0-6-gae77429+3,18.1.0-7-g9d75d83+9,18.1.0-7-gae09a6d+30,18.1.0-9-gc381ef5+4,w.2019.45
LSSTDataManagementBasePackage
_LinearTransform.cc
Go to the documentation of this file.
1 /*
2  * Developed for the LSST Data Management System.
3  * This product includes software developed by the LSST Project
4  * (https://www.lsst.org).
5  * See the COPYRIGHT file at the top-level directory of this distribution
6  * for details of code ownership.
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program. If not, see <https://www.gnu.org/licenses/>.
20  */
21 
22 #include "pybind11/pybind11.h"
23 #include "pybind11/eigen.h"
24 #include "pybind11/stl.h"
25 #include "pybind11/numpy.h"
26 
27 #include "ndarray/pybind11.h"
28 
29 #include "lsst/utils/python.h"
30 
31 #include "lsst/geom/Extent.h"
32 #include "lsst/geom/Point.h"
34 
35 namespace py = pybind11;
36 using namespace pybind11::literals;
37 
38 namespace lsst {
39 namespace geom {
40 
42  wrappers.wrapType(
43  py::class_<LinearTransform, std::shared_ptr<LinearTransform>>(wrappers.module, "LinearTransform"),
44  [](auto & mod, auto & cls) {
45 
46  // Parameters enum is really only used as integer constants.
47  cls.attr("XX") = py::cast(int(LinearTransform::Parameters::XX));
48  cls.attr("YX") = py::cast(int(LinearTransform::Parameters::YX));
49  cls.attr("XY") = py::cast(int(LinearTransform::Parameters::XY));
50  cls.attr("YY") = py::cast(int(LinearTransform::Parameters::YY));
51 
52  /* Constructors */
53  cls.def(py::init<>());
54  cls.def(py::init<LinearTransform::Matrix const &>(), "matrix"_a);
55 
56  /* Operators */
57  cls.def("__call__",
58  py::overload_cast<Point2D const &>(&LinearTransform::operator(), py::const_));
59  cls.def("__call__",
60  py::overload_cast<Extent2D const &>(&LinearTransform::operator(), py::const_));
61  cls.def("__call__",
62  // We use pybind11's wrappers for the Python C API to
63  // delegate to other wrapped methods because:
64  // - defining this in pure Python is tricky because it's
65  // an overload, not a standalone method;
66  // - we'd rather not add a new pure-Python file just for
67  // this;
68  // - using py::vectorize internal to the method would
69  // involve defining a new internal callable every time
70  // this method is called.
71  // The other viable alternative would be to define
72  // applyX and applyY as Python callables with py::vectorize
73  // outside the lambda as C++ local variables, and then
74  // capture them by value in the lambda. This just seems
75  // slightly cleaner, as it's closer to how one would
76  // implement this in pure Python, if it wasn't an overload.
77  [](py::object self, py::object x, py::object y) {
78  return py::make_tuple(self.attr("applyX")(x, y),
79  self.attr("applyY")(x, y));
80  },
81  "x"_a, "y"_a);
82  cls.def("__getitem__",
83  [](LinearTransform const &self, int i) { return self[utils::python::cppIndex(4, i)]; });
84  cls.def("__getitem__", [](LinearTransform const &self, std::pair<int, int> i) {
85  auto row = utils::python::cppIndex(2, i.first);
86  auto col = utils::python::cppIndex(2, i.second);
87  return self.getMatrix()(row, col);
88  });
89  cls.def("__mul__", &LinearTransform::operator*, py::is_operator());
90  cls.def("__add__", &LinearTransform::operator+, py::is_operator());
91  cls.def("__sub__", &LinearTransform::operator-, py::is_operator());
92  cls.def("__iadd__", &LinearTransform::operator+=);
93  cls.def("__isub__", &LinearTransform::operator-=);
94 
95  /* Members */
96  cls.def_static("makeScaling",
97  py::overload_cast<double>(&LinearTransform::makeScaling),
98  "scale"_a);
99  cls.def_static("makeScaling",
100  py::overload_cast<double, double>(&LinearTransform::makeScaling));
101  cls.def_static("makeRotation",
102  py::overload_cast<Angle>(LinearTransform::makeRotation),
103  "angle"_a);
104  cls.def("getParameterVector", &LinearTransform::getParameterVector);
105  cls.def("getMatrix",
106  py::overload_cast<>(& LinearTransform::getMatrix, py::const_));
107  cls.def("inverted", &LinearTransform::inverted);
108  cls.def("computeDeterminant", &LinearTransform::computeDeterminant);
109  cls.def("isIdentity", &LinearTransform::isIdentity);
110  cls.def("applyX", py::vectorize(&LinearTransform::applyX), "x"_a, "y"_a);
111  cls.def("applyY", py::vectorize(&LinearTransform::applyY), "x"_a, "y"_a);
112 
113  cls.def("set",
114  [](LinearTransform &self, double xx, double yx, double xy, double yy) {
115  self[LinearTransform::XX] = xx;
116  self[LinearTransform::XY] = xy;
117  self[LinearTransform::YX] = yx;
118  self[LinearTransform::YY] = yy;
119  },
120  "xx"_a, "yx"_a, "xy"_a, "yy"_a);
121 
122  cls.def("__str__", [](LinearTransform const &self) {
123  return py::str(py::cast(self.getMatrix()));
124  });
125  cls.def("__repr__", [](LinearTransform const &self) {
126  return py::str("LinearTransform(\n{}\n)").format(py::cast(self.getMatrix()));
127  });
128  cls.def("__reduce__", [cls](LinearTransform const &self) {
129  return py::make_tuple(cls, py::make_tuple(py::cast(self.getMatrix())));
130  });
131  }
132  );
133 }
134 
135 } // namespace geom
136 } // namespace lsst
int col
Definition: CR.cc:144
std::size_t cppIndex(std::ptrdiff_t size, std::ptrdiff_t i)
Compute a C++ index from a Python index (negative values count from the end) and range-check.
Definition: python.h:124
pybind11::module module
The module object passed to the PYBIND11_MODULE block that contains this WrapperCollection.
Definition: python.h:448
void wrapLinearTransform(WrapperCollection &wrappers)
A base class for image defects.
A helper class for subdividing pybind11 module across multiple translation units (i.e.
Definition: python.h:242
A 2D linear coordinate transformation.
PyType wrapType(PyType cls, ClassWrapperCallback function, bool setModuleName=true)
Add a type (class or enum) wrapper, deferring method and other attribute definitions until finish() i...
Definition: python.h:391
int row
Definition: CR.cc:145