LSSTApplications  19.0.0-14-gb0260a2+72efe9b372,20.0.0+7927753e06,20.0.0+8829bf0056,20.0.0+995114c5d2,20.0.0+b6f4b2abd1,20.0.0+bddc4f4cbe,20.0.0-1-g253301a+8829bf0056,20.0.0-1-g2b7511a+0d71a2d77f,20.0.0-1-g5b95a8c+7461dd0434,20.0.0-12-g321c96ea+23efe4bbff,20.0.0-16-gfab17e72e+fdf35455f6,20.0.0-2-g0070d88+ba3ffc8f0b,20.0.0-2-g4dae9ad+ee58a624b3,20.0.0-2-g61b8584+5d3db074ba,20.0.0-2-gb780d76+d529cf1a41,20.0.0-2-ged6426c+226a441f5f,20.0.0-2-gf072044+8829bf0056,20.0.0-2-gf1f7952+ee58a624b3,20.0.0-20-geae50cf+e37fec0aee,20.0.0-25-g3dcad98+544a109665,20.0.0-25-g5eafb0f+ee58a624b3,20.0.0-27-g64178ef+f1f297b00a,20.0.0-3-g4cc78c6+e0676b0dc8,20.0.0-3-g8f21e14+4fd2c12c9a,20.0.0-3-gbd60e8c+187b78b4b8,20.0.0-3-gbecbe05+48431fa087,20.0.0-38-ge4adf513+a12e1f8e37,20.0.0-4-g97dc21a+544a109665,20.0.0-4-gb4befbc+087873070b,20.0.0-4-gf910f65+5d3db074ba,20.0.0-5-gdfe0fee+199202a608,20.0.0-5-gfbfe500+d529cf1a41,20.0.0-6-g64f541c+d529cf1a41,20.0.0-6-g9a5b7a1+a1cd37312e,20.0.0-68-ga3f3dda+5fca18c6a4,20.0.0-9-g4aef684+e18322736b,w.2020.45
LSSTDataManagementBasePackage
_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 
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
y
int y
Definition: SpanSet.cc:49
std::make_tuple
T make_tuple(T... args)
std::shared_ptr
STL class.
Box.h
python.h
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
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
astshim.fitsChanContinued.contains
def contains(self, name)
Definition: fitsChanContinued.py:127
x
double x
Definition: ChebyshevBoundedField.cc:277
other
ItemVariant const * other
Definition: Schema.cc:56
lsst::geom::wrapBox
void wrapBox(utils::python::WrapperCollection &wrappers)
Definition: _Box.cc:35
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
lsst::geom
Definition: AffineTransform.h:36
lsst::afw::cameraGeom::swap
void swap(CameraSys &a, CameraSys &b)
Definition: CameraSys.h:157
lsst::geom::Box2I
An integer coordinate rectangle.
Definition: Box.h:55
pybind11
Definition: _GenericMap.cc:40
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
lsst::sphgeom::EPSILON
constexpr double EPSILON
Definition: constants.h:54