35 {
36 wrappers.wrapType(
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(corner={}, 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(
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_));
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(corner={}, 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}
An integer coordinate rectangle.
