LSSTApplications  20.0.0
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
std::shared_ptr
STL class.
std::pair< int, int >
lsst::geom::LinearTransform
A 2D linear coordinate transformation.
Definition: LinearTransform.h:69
lsst::utils::python::cppIndex
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
lsst::geom::wrapLinearTransform
void wrapLinearTransform(WrapperCollection &wrappers)
Definition: _LinearTransform.cc:41
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
Extent.h
lsst::utils::python::WrapperCollection::wrapType
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
LinearTransform.h
lsst::utils::python::WrapperCollection
A helper class for subdividing pybind11 module across multiple translation units (i....
Definition: python.h:242
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
python.h
lsst::geom
Definition: geomOperators.dox:4
row
int row
Definition: CR.cc:145
col
int col
Definition: CR.cc:144
pybind11
Definition: _GenericMap.cc:40
Point.h
lsst::utils::python::WrapperCollection::module
pybind11::module module
The module object passed to the PYBIND11_MODULE block that contains this WrapperCollection.
Definition: python.h:448