38 [](
auto & mod,
auto & cls)
mutable {
40 cls.attr(
"Point") = mod.attr(
"Point2I");
41 cls.attr(
"Extent") = mod.attr(
"Extent2I");
43 py::enum_<Box2I::EdgeHandlingEnum>(cls,
"EdgeHandlingEnum")
44 .value(
"EXPAND", Box2I::EdgeHandlingEnum::EXPAND)
45 .value(
"SHRINK", Box2I::EdgeHandlingEnum::SHRINK)
48 cls.def(py::init<>());
49 cls.def(py::init<Point2I const &, Point2I const &, bool>(),
"minimum"_a,
"maximum"_a,
51 cls.def(py::init<Point2I const &, Extent2I const &, bool>(),
"corner"_a,
"dimensions"_a,
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);
58 cls.def(
"__eq__", [](Box2I const &self, Box2I const &other) { return self == other; },
60 cls.def(
"__ne__", [](Box2I
const &
self, Box2I
const &other) {
return self != other; },
63 cls.def_static(
"makeCenteredBox", &Box2I::makeCenteredBox,
"center"_a,
"size"_a);
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_));
105 py::vectorize(
static_cast<bool (Box2I::*)(
int x,
int y) const
>(&
Box2I::contains)),
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())));
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())));
140 cls.def(
"__reduce__", [cls](Box2I
const &
self) {
141 return py::make_tuple(cls,
make_tuple(py::cast(
self.getMin()), py::cast(
self.getMax())));
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));
147 cls.def(
"getSlices", getSlices);
148 cls.def_property_readonly(
"slices", getSlices);
150 mod.attr(
"BoxI") = cls;
156 [](
auto & mod,
auto & cls)
mutable {
158 cls.attr(
"Point") = mod.attr(
"Point2D");
159 cls.attr(
"Extent") = mod.attr(
"Extent2D");
162 cls.attr(
"INVALID") = py::float_(Box2D::INVALID);
164 cls.def(py::init<>());
165 cls.def(py::init<Point2D const &, Point2D const &, bool>(),
"minimum"_a,
"maximum"_a,
167 cls.def(py::init<Point2D const &, Extent2D const &, bool>(),
"corner"_a,
"dimensions"_a,
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 &>());
173 cls.def(
"__eq__", [](Box2D
const &
self, Box2D
const &other) {
return self == other; },
175 cls.def(
"__ne__", [](Box2D
const &
self, Box2D
const &other) {
return self != other; },
178 cls.def_static(
"makeCenteredBox", &Box2D::makeCenteredBox,
"center"_a,
"size"_a);
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)),
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())));
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())));
245 cls.def(
"__reduce__", [cls](Box2D
const &
self) {
246 return py::make_tuple(cls,
make_tuple(py::cast(
self.getMin()), py::cast(
self.getMax())));
249 mod.attr(
"BoxD") = cls;
void swap(CameraSys &a, CameraSys &b)
