LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
_Box.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/stl.h"
24 #include "pybind11/numpy.h"
25 
26 #include "lsst/geom/Box.h"
27 #include "lsst/utils/python.h"
28 
29 namespace py = pybind11;
30 using namespace py::literals;
31 
32 namespace lsst {
33 namespace geom {
34 
35 void wrapBox(utils::python::WrapperCollection & wrappers) {
36  wrappers.wrapType(
37  py::class_<Box2I, std::shared_ptr<Box2I>>(wrappers.module, "Box2I"),
38  [](auto & mod, auto & cls) mutable {
39 
40  cls.attr("Point") = mod.attr("Point2I");
41  cls.attr("Extent") = mod.attr("Extent2I");
42 
43  py::enum_<Box2I::EdgeHandlingEnum>(cls, "EdgeHandlingEnum")
44  .value("EXPAND", Box2I::EdgeHandlingEnum::EXPAND)
45  .value("SHRINK", Box2I::EdgeHandlingEnum::SHRINK)
46  .export_values();
47 
48  cls.def(py::init<>());
49  cls.def(py::init<Point2I const &, Point2I const &, bool>(), "minimum"_a, "maximum"_a,
50  "invert"_a = true);
51  cls.def(py::init<Point2I const &, Extent2I const &, bool>(), "corner"_a, "dimensions"_a,
52  "invert"_a = true);
53  cls.def(py::init<IntervalI const &, IntervalI const &>(), "x"_a, "y"_a);
54  cls.def(py::init<Box2D const &, Box2I::EdgeHandlingEnum>(), "other"_a,
55  "edgeHandling"_a = Box2I::EXPAND);
56  cls.def(py::init<Box2I const &>(), "other"_a);
57 
58  cls.def("__eq__", [](Box2I const &self, Box2I const &other) { return self == other; },
59  py::is_operator());
60  cls.def("__ne__", [](Box2I const &self, Box2I const &other) { return self != other; },
61  py::is_operator());
62 
63  cls.def_static("makeCenteredBox", &Box2I::makeCenteredBox, "center"_a, "size"_a);
64  cls.def("swap", &Box2I::swap);
65  cls.def("getMin", &Box2I::getMin);
66  cls.def("getMinX", &Box2I::getMinX);
67  cls.def("getMinY", &Box2I::getMinY);
68  cls.def("getMax", &Box2I::getMax);
69  cls.def("getMaxX", &Box2I::getMaxX);
70  cls.def("getMaxY", &Box2I::getMaxY);
71  cls.def_property_readonly("minX", &Box2I::getMinX);
72  cls.def_property_readonly("minY", &Box2I::getMinY);
73  cls.def_property_readonly("maxX", &Box2I::getMaxX);
74  cls.def_property_readonly("maxY", &Box2I::getMaxY);
75  cls.def("getBegin", &Box2I::getBegin);
76  cls.def("getBeginX", &Box2I::getBeginX);
77  cls.def("getBeginY", &Box2I::getBeginY);
78  cls.def("getEnd", &Box2I::getEnd);
79  cls.def("getEndX", &Box2I::getEndX);
80  cls.def("getEndY", &Box2I::getEndY);
81  cls.def_property_readonly("beginX", &Box2I::getBeginX);
82  cls.def_property_readonly("beginY", &Box2I::getBeginY);
83  cls.def_property_readonly("endX", &Box2I::getEndX);
84  cls.def_property_readonly("endY", &Box2I::getEndY);
85  cls.def("getDimensions", &Box2I::getDimensions);
86  cls.def("getWidth", &Box2I::getWidth);
87  cls.def("getHeight", &Box2I::getHeight);
88  cls.def("getArea", &Box2I::getArea);
89  cls.def_property_readonly("width", &Box2I::getWidth);
90  cls.def_property_readonly("height", &Box2I::getHeight);
91  cls.def_property_readonly("area", &Box2I::getArea);
92  cls.def("getCenter", &Box2I::getCenter);
93  cls.def("getCenterX", &Box2I::getCenterX);
94  cls.def("getCenterY", &Box2I::getCenterY);
95  cls.def_property_readonly("centerX", &Box2I::getCenterX);
96  cls.def_property_readonly("centerY", &Box2I::getCenterY);
97  cls.def("getX", &Box2I::getX);
98  cls.def("getY", &Box2I::getY);
99  cls.def_property_readonly("x", &Box2I::getX);
100  cls.def_property_readonly("y", &Box2I::getY);
101  cls.def("isEmpty", &Box2I::isEmpty);
102  cls.def("contains", py::overload_cast<Point2I const &>(&Box2I::contains, py::const_));
103  cls.def("contains", py::overload_cast<Box2I const &>(&Box2I::contains, py::const_));
104  cls.def("contains",
105  py::vectorize(static_cast<bool (Box2I::*)(int x, int y) const>(&Box2I::contains)),
106  "x"_a, "y"_a);
107  cls.def("__contains__", py::overload_cast<Point2I const &>(&Box2I::contains, py::const_));
108  cls.def("__contains__", py::overload_cast<Box2I const &>(&Box2I::contains, py::const_));
109  cls.def("overlaps", &Box2I::overlaps);
110  cls.def("intersects", &Box2I::intersects);
111  cls.def("isDisjointFrom", &Box2I::isDisjointFrom);
112  cls.def("grow", py::overload_cast<int>(&Box2I::grow));
113  cls.def("grow", py::overload_cast<Extent2I const &>(&Box2I::grow));
114  cls.def("shift", &Box2I::shift);
115  cls.def("flipLR", &Box2I::flipLR);
116  cls.def("flipTB", &Box2I::flipTB);
117  cls.def("include", py::overload_cast<Point2I const &>(&Box2I::include));
118  cls.def("include", py::overload_cast<Box2I const &>(&Box2I::include));
119  cls.def("clip", &Box2I::clip);
120  cls.def("dilatedBy", py::overload_cast<int>(&Box2I::dilatedBy, py::const_));
121  cls.def("dilatedBy", py::overload_cast<Extent2I const &>(&Box2I::dilatedBy, py::const_));
122  cls.def("erodedBy", py::overload_cast<int>(&Box2I::erodedBy, py::const_));
123  cls.def("erodedBy", py::overload_cast<Extent2I const &>(&Box2I::erodedBy, py::const_));
124  cls.def("shiftedBy", &Box2I::shiftedBy);
125  cls.def("reflectedAboutX", &Box2I::reflectedAboutX);
126  cls.def("reflectedAboutY", &Box2I::reflectedAboutY);
127  cls.def("expandedTo", py::overload_cast<Point2I const &>(&Box2I::expandedTo, py::const_));
128  cls.def("expandedTo", py::overload_cast<Box2I const &>(&Box2I::expandedTo, py::const_));
129  cls.def("clippedTo", &Box2I::clippedTo);
130  cls.def("getCorners", &Box2I::getCorners);
131  cls.def("toString", &Box2I::toString);
132  cls.def("__repr__", [](Box2I const &self) {
133  return py::str("Box2I(minimum={}, dimensions={})")
134  .format(py::repr(py::cast(self.getMin())), py::repr(py::cast(self.getDimensions())));
135  });
136  cls.def("__str__", [](Box2I const &self) {
137  return py::str("(minimum={}, maximum={})")
138  .format(py::str(py::cast(self.getMin())), py::str(py::cast(self.getMax())));
139  });
140  cls.def("__reduce__", [cls](Box2I const &self) {
141  return py::make_tuple(cls, make_tuple(py::cast(self.getMin()), py::cast(self.getMax())));
142  });
143  auto getSlices = [](Box2I const &self) {
144  return py::make_tuple(py::slice(self.getBeginY(), self.getEndY(), 1),
145  py::slice(self.getBeginX(), self.getEndX(), 1));
146  };
147  cls.def("getSlices", getSlices);
148  cls.def_property_readonly("slices", getSlices);
149 
150  mod.attr("BoxI") = cls;
151  }
152  );
153 
154  wrappers.wrapType(
155  py::class_<Box2D, std::shared_ptr<Box2D>>(wrappers.module, "Box2D"),
156  [](auto & mod, auto & cls) mutable {
157 
158  cls.attr("Point") = mod.attr("Point2D");
159  cls.attr("Extent") = mod.attr("Extent2D");
160 
161  cls.attr("EPSILON") = py::float_(Box2D::EPSILON);
162  cls.attr("INVALID") = py::float_(Box2D::INVALID);
163 
164  cls.def(py::init<>());
165  cls.def(py::init<Point2D const &, Point2D const &, bool>(), "minimum"_a, "maximum"_a,
166  "invert"_a = true);
167  cls.def(py::init<Point2D const &, Extent2D const &, bool>(), "corner"_a, "dimensions"_a,
168  "invert"_a = true);
169  cls.def(py::init<IntervalD const &, IntervalD const &>(), "x"_a, "y"_a);
170  cls.def(py::init<Box2I const &>());
171  cls.def(py::init<Box2D const &>());
172 
173  cls.def("__eq__", [](Box2D const &self, Box2D const &other) { return self == other; },
174  py::is_operator());
175  cls.def("__ne__", [](Box2D const &self, Box2D const &other) { return self != other; },
176  py::is_operator());
177 
178  cls.def_static("makeCenteredBox", &Box2D::makeCenteredBox, "center"_a, "size"_a);
179  cls.def("swap", &Box2D::swap);
180  cls.def("getMin", &Box2D::getMin);
181  cls.def("getMinX", &Box2D::getMinX);
182  cls.def("getMinY", &Box2D::getMinY);
183  cls.def("getMax", &Box2D::getMax);
184  cls.def("getMaxX", &Box2D::getMaxX);
185  cls.def("getMaxY", &Box2D::getMaxY);
186  cls.def_property_readonly("minX", &Box2D::getMinX);
187  cls.def_property_readonly("minY", &Box2D::getMinY);
188  cls.def_property_readonly("maxX", &Box2D::getMaxX);
189  cls.def_property_readonly("maxY", &Box2D::getMaxY);
190  cls.def("getDimensions", &Box2D::getDimensions);
191  cls.def("getWidth", &Box2D::getWidth);
192  cls.def("getHeight", &Box2D::getHeight);
193  cls.def("getArea", &Box2D::getArea);
194  cls.def_property_readonly("width", &Box2D::getWidth);
195  cls.def_property_readonly("height", &Box2D::getHeight);
196  cls.def_property_readonly("area", &Box2D::getArea);
197  cls.def("getX", &Box2D::getX);
198  cls.def("getY", &Box2D::getY);
199  cls.def_property_readonly("x", &Box2D::getX);
200  cls.def_property_readonly("y", &Box2D::getY);
201  cls.def("getCenter", &Box2D::getCenter);
202  cls.def("getCenterX", &Box2D::getCenterX);
203  cls.def("getCenterY", &Box2D::getCenterY);
204  cls.def_property_readonly("centerX", &Box2D::getCenterX);
205  cls.def_property_readonly("centerY", &Box2D::getCenterY);
206  cls.def("isEmpty", &Box2D::isEmpty);
207  cls.def("contains", py::overload_cast<Point2D const &>(&Box2D::contains, py::const_));
208  cls.def("contains", py::overload_cast<Box2D const &>(&Box2D::contains, py::const_));
209  cls.def("contains",
210  py::vectorize(static_cast<bool (Box2D::*)(double x, double y) const>(&Box2D::contains)),
211  "x"_a, "y"_a);
212  cls.def("__contains__", py::overload_cast<Point2D const &>(&Box2D::contains, py::const_));
213  cls.def("__contains__", py::overload_cast<Box2D const &>(&Box2D::contains, py::const_));
214  cls.def("intersects", &Box2D::intersects);
215  cls.def("isDisjointFrom", &Box2D::isDisjointFrom);
216  cls.def("overlaps", &Box2D::overlaps);
217  cls.def("grow", py::overload_cast<double>(&Box2D::grow));
218  cls.def("grow", py::overload_cast<Extent2D const &>(&Box2D::grow));
219  cls.def("shift", &Box2D::shift);
220  cls.def("flipLR", &Box2D::flipLR);
221  cls.def("flipTB", &Box2D::flipTB);
222  cls.def("include", py::overload_cast<Point2D const &>(&Box2D::include));
223  cls.def("include", py::overload_cast<Box2D const &>(&Box2D::include));
224  cls.def("clip", &Box2D::clip);
225  cls.def("dilatedBy", py::overload_cast<double>(&Box2D::dilatedBy, py::const_));
226  cls.def("dilatedBy", py::overload_cast<Extent2D const &>(&Box2D::dilatedBy, py::const_));
227  cls.def("erodedBy", py::overload_cast<double>(&Box2D::erodedBy, py::const_));
228  cls.def("erodedBy", py::overload_cast<Extent2D const &>(&Box2D::erodedBy, py::const_));
229  cls.def("shiftedBy", &Box2D::shiftedBy);
230  cls.def("reflectedAboutX", &Box2D::reflectedAboutX);
231  cls.def("reflectedAboutY", &Box2D::reflectedAboutY);
232  cls.def("expandedTo", py::overload_cast<Point2D const &>(&Box2D::expandedTo, py::const_));
233  cls.def("expandedTo", py::overload_cast<Box2D const &>(&Box2D::expandedTo, py::const_));
234  cls.def("clippedTo", &Box2D::clippedTo);
235  cls.def("getCorners", &Box2D::getCorners);
236  cls.def("toString", &Box2D::toString);
237  cls.def("__repr__", [](Box2D const &self) {
238  return py::str("Box2D(minimum={}, dimensions={})")
239  .format(py::repr(py::cast(self.getMin())), py::repr(py::cast(self.getDimensions())));
240  });
241  cls.def("__str__", [](Box2D const &self) {
242  return py::str("(minimum={}, maximum={})")
243  .format(py::str(py::cast(self.getMin())), py::str(py::cast(self.getMax())));
244  });
245  cls.def("__reduce__", [cls](Box2D const &self) {
246  return py::make_tuple(cls, make_tuple(py::cast(self.getMin()), py::cast(self.getMax())));
247  });
248 
249  mod.attr("BoxD") = cls;
250  }
251  );
252 }
253 
254 } // namespace geom
255 } // namespace lsst
x
double x
Definition: ChebyshevBoundedField.cc:276
y
int y
Definition: SpanSet.cc:48
lsst::geom::Box2I
An integer coordinate rectangle.
Definition: Box.h:55
std::make_tuple
T make_tuple(T... args)
lsst::afw::cameraGeom::swap
void swap(CameraSys &a, CameraSys &b)
Definition: CameraSys.h:157
lsst::geom::wrapBox
void wrapBox(utils::python::WrapperCollection &wrappers)
Definition: _Box.cc:35
lsst::sphgeom::EPSILON
constexpr double EPSILON
Definition: constants.h:54
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
Generated on Fri Nov 26 2021 10:16:02 for LSST Applications by doxygen 1.9.1