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
_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
35namespace py = pybind11;
36using namespace pybind11::literals;
37
38namespace lsst {
39namespace geom {
40
41void wrapLinearTransform(utils::python::WrapperCollection & wrappers) {
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
A 2D linear coordinate transformation.
double applyX(double x, double y) const noexcept
Transform a point given and returned as separate double values.
ParameterVector const getParameterVector() const noexcept
Return the transform matrix elements as a parameter vector.
Matrix const & getMatrix() const noexcept
static LinearTransform makeRotation(Angle t) noexcept
double applyY(double x, double y) const noexcept
static LinearTransform makeScaling(double s) noexcept
bool isIdentity() const noexcept
Whether the transform is a no-op.
LinearTransform const inverted() const
Return the inverse transform.
double computeDeterminant() const noexcept
Return the determinant of the 2x2 matrix.
void wrapLinearTransform(WrapperCollection &wrappers)
int row
Definition CR.cc:145
int col
Definition CR.cc:144