1 #ifndef LIBNR_NR_RECT_H_SEEN
2 #define LIBNR_NR_RECT_H_SEEN
4 /** \file
5 * Definitions of NRRect and NR::Rect types, and some associated functions \& macros.
6 */
7 /*
8 * Authors:
9 * Lauris Kaplinski <lauris@kaplinski.com>
10 * Nathan Hurst <njh@mail.csse.monash.edu.au>
11 * MenTaLguY <mental@rydia.net>
12 *
13 * This code is in public domain
14 */
17 #include <stdexcept>
18 #include <limits>
20 #include "libnr/nr-values.h"
21 #include <libnr/nr-coord.h>
22 #include <libnr/nr-i-coord.h>
23 #include <libnr/nr-dim2.h>
24 #include <libnr/nr-point.h>
25 #include <libnr/nr-maybe.h>
26 #include <libnr/nr-point-matrix-ops.h>
28 namespace NR {
29 struct Matrix;
31 /** A rectangle is always aligned to the X and Y axis. This means it
32 * can be defined using only 4 coordinates, and determining
33 * intersection is very efficient. The points inside a rectangle are
34 * min[dim] <= _pt[dim] <= max[dim]. A rectangle may be empty, in the
35 * sense of having zero area, but it will always contain at least one
36 * point. Infinities are also permitted.
37 */
38 class Rect {
39 public:
40 Rect() : _min(-_inf(), -_inf()), _max(_inf(), _inf()) {}
41 Rect(Point const &p0, Point const &p1);
43 Point const &min() const { return _min; }
44 Point const &max() const { return _max; }
46 /** returns the four corners of the rectangle in order
47 * (clockwise if +Y is up, anticlockwise if +Y is down) */
48 Point corner(unsigned i) const;
50 /** returns a vector from min to max. */
51 Point dimensions() const;
53 /** returns the midpoint of this rect. */
54 Point midpoint() const;
56 bool isEmpty(double epsilon=1e-6) const {
57 return isEmpty<X>(epsilon) || isEmpty<Y>(epsilon);
58 }
60 bool intersects(Rect const &r) const {
61 return intersects<X>(r) && intersects<Y>(r);
62 }
63 bool contains(Rect const &r) const {
64 return contains<X>(r) && contains<Y>(r);
65 }
66 bool contains(Point const &p) const {
67 return contains<X>(p) && contains<Y>(p);
68 }
70 double area() const {
71 return extent<X>() * extent<Y>();
72 }
74 double maxExtent() const {
75 return MAX(extent<X>(), extent<Y>());
76 }
78 double extent(Dim2 const axis) const {
79 switch (axis) {
80 case X: return extent<X>();
81 case Y: return extent<Y>();
82 default: g_error("invalid axis value %d", (int) axis); return 0;
83 };
84 }
86 double extent(unsigned i) const throw(std::out_of_range) {
87 switch (i) {
88 case 0: return extent<X>();
89 case 1: return extent<Y>();
90 default: throw std::out_of_range("Dimension out of range");
91 };
92 }
94 /**
95 \brief Remove some precision from the Rect
96 \param places The number of decimal places left in the end
98 This function just calls round on the \c _min and \c _max points.
99 */
100 inline void round(int places = 0) {
101 _min.round(places);
102 _max.round(places);
103 return;
104 }
106 /** Translates the rectangle by p. */
107 void offset(Point p);
109 /** Makes this rectangle large enough to include the point p. */
110 void expandTo(Point p);
112 /** Makes this rectangle large enough to include the rectangle r. */
113 void expandTo(Rect const &r);
115 inline void move_left (gdouble by) {
116 _min[NR::X] += by;
117 }
118 inline void move_right (gdouble by) {
119 _max[NR::X] += by;
120 }
121 inline void move_top (gdouble by) {
122 _min[NR::Y] += by;
123 }
124 inline void move_bottom (gdouble by) {
125 _max[NR::Y] += by;
126 }
128 void growBy (gdouble by);
130 /** Scales the rect by s, with origin at 0, 0 */
131 inline Rect operator*(double const s) const {
132 return Rect(s * min(), s * max());
133 }
135 /** Transforms the rect by m. Note that it gives correct results only for scales and translates */
136 inline Rect operator*(Matrix const m) const {
137 return Rect(_min * m, _max * m);
138 }
140 inline bool operator==(Rect const &in_rect) {
141 return ((this->min() == in_rect.min()) && (this->max() == in_rect.max()));
142 }
144 friend inline std::ostream &operator<<(std::ostream &out_file, NR::Rect const &in_rect);
146 private:
147 Rect(Nothing) : _min(1, 1), _max(-1, -1) {}
149 static double _inf() {
150 return std::numeric_limits<double>::infinity();
151 }
153 template <NR::Dim2 axis>
154 double extent() const {
155 return _max[axis] - _min[axis];
156 }
158 template <NR::Dim2 axis>
159 bool isEmpty(double epsilon) const {
160 return extent<axis>() < epsilon;
161 }
163 template <Dim2 axis>
164 bool intersects(Rect const &r) const {
165 return _max[axis] >= r._min[axis] && _min[axis] <= r._max[axis];
166 }
168 template <Dim2 axis>
169 bool contains(Rect const &r) const {
170 return contains(r._min) && contains(r._max);
171 }
173 template <Dim2 axis>
174 bool contains(Point const &p) const {
175 return p[axis] >= _min[axis] && p[axis] <= _max[axis];
176 }
178 Point _min, _max;
180 friend class MaybeStorage<Rect>;
181 friend Maybe<Rect> intersection(Maybe<Rect> const &, Maybe<Rect> const &);
182 friend Rect union_bounds(Rect const &, Rect const &);
183 };
185 template <>
186 class MaybeStorage<Rect> {
187 public:
188 MaybeStorage() : _rect(Nothing()) {}
189 MaybeStorage(Rect const &rect) : _rect(rect) {}
191 bool is_nothing() const {
192 return _rect._min[X] > _rect._max[X];
193 }
194 Rect const &value() const { return _rect; }
195 Rect &value() { return _rect; }
197 private:
198 Rect _rect;
199 };
201 /** Returns the set of points shared by both rectangles. */
202 Maybe<Rect> intersection(Maybe<Rect> const & a, Maybe<Rect> const & b);
204 /** Returns the smallest rectangle that encloses both rectangles. */
205 Rect union_bounds(Rect const &a, Rect const &b);
206 inline Rect union_bounds(Maybe<Rect> const & a, Rect const &b) {
207 if (a) {
208 return union_bounds(*a, b);
209 } else {
210 return b;
211 }
212 }
213 inline Rect union_bounds(Rect const &a, Maybe<Rect> const & b) {
214 if (b) {
215 return union_bounds(a, *b);
216 } else {
217 return a;
218 }
219 }
220 inline Maybe<Rect> union_bounds(Maybe<Rect> const & a, Maybe<Rect> const & b)
221 {
222 if (!a) {
223 return b;
224 } else if (!b) {
225 return a;
226 } else {
227 return union_bounds(*a, *b);
228 }
229 }
231 /** A function to print out the rectange if sent to an output
232 stream. */
233 inline std::ostream
234 &operator<<(std::ostream &out_file, NR::Rect const &in_rect)
235 {
236 out_file << "Rectangle:\n";
237 out_file << "\tMin Point -> " << in_rect.min() << "\n";
238 out_file << "\tMax Point -> " << in_rect.max() << "\n";
240 return out_file;
241 }
243 } /* namespace NR */
245 /* legacy rect stuff */
247 struct NRMatrix;
249 /* NULL rect is infinite */
251 struct NRRect {
252 NRRect() {}
253 NRRect(NR::Coord xmin, NR::Coord ymin, NR::Coord xmax, NR::Coord ymax)
254 : x0(xmin), y0(ymin), x1(xmin), y1(ymin)
255 {}
256 explicit NRRect(NR::Rect const &rect);
257 explicit NRRect(NR::Maybe<NR::Rect> const &rect);
258 operator NR::Maybe<NR::Rect>() const { return upgrade(); }
259 NR::Maybe<NR::Rect> upgrade() const;
261 NR::Coord x0, y0, x1, y1;
262 };
264 #define nr_rect_d_set_empty(r) (*(r) = NR_RECT_EMPTY)
265 #define nr_rect_l_set_empty(r) (*(r) = NR_RECT_L_EMPTY)
267 #define nr_rect_d_test_empty(r) ((r) && NR_RECT_DFLS_TEST_EMPTY(r))
268 #define nr_rect_l_test_empty(r) ((r) && NR_RECT_DFLS_TEST_EMPTY(r))
270 #define nr_rect_d_test_intersect(r0,r1) \
271 (!nr_rect_d_test_empty(r0) && !nr_rect_d_test_empty(r1) && \
272 !((r0) && (r1) && !NR_RECT_DFLS_TEST_INTERSECT(r0, r1)))
273 #define nr_rect_l_test_intersect(r0,r1) \
274 (!nr_rect_l_test_empty(r0) && !nr_rect_l_test_empty(r1) && \
275 !((r0) && (r1) && !NR_RECT_DFLS_TEST_INTERSECT(r0, r1)))
277 #define nr_rect_d_point_d_test_inside(r,p) ((p) && (!(r) || (!NR_RECT_DF_TEST_EMPTY(r) && NR_RECT_DF_POINT_DF_TEST_INSIDE(r,p))))
278 #define nr_rect_l_point_l_test_inside(r,p) ((p) && (!(r) || (!NR_RECT_DFLS_TEST_EMPTY(r) && NR_RECT_LS_POINT_LS_TEST_INSIDE(r,p))))
279 #define nr_rect_l_test_inside(r,x,y) ((!(r) || (!NR_RECT_DFLS_TEST_EMPTY(r) && NR_RECT_LS_TEST_INSIDE(r,x,y))))
281 // returns minimal rect which covers all of r0 not covered by r1
282 NRRectL *nr_rect_l_subtract(NRRectL *d, NRRectL const *r0, NRRectL const *r1);
284 // returns the area of r
285 NR::ICoord nr_rect_l_area(NRRectL *r);
287 /* NULL values are OK for r0 and r1, but not for d */
288 NRRect *nr_rect_d_intersect(NRRect *d, NRRect const *r0, NRRect const *r1);
289 NRRectL *nr_rect_l_intersect(NRRectL *d, NRRectL const *r0, NRRectL const *r1);
291 NRRect *nr_rect_d_union(NRRect *d, NRRect const *r0, NRRect const *r1);
292 NRRectL *nr_rect_l_union(NRRectL *d, NRRectL const *r0, NRRectL const *r1);
294 NRRect *nr_rect_union_pt(NRRect *dst, NR::Point const &p);
295 NRRect *nr_rect_d_union_xy(NRRect *d, NR::Coord x, NR::Coord y);
296 NRRectL *nr_rect_l_union_xy(NRRectL *d, NR::ICoord x, NR::ICoord y);
298 NRRect *nr_rect_d_matrix_transform(NRRect *d, NRRect const *s, NR::Matrix const &m);
299 NRRect *nr_rect_d_matrix_transform(NRRect *d, NRRect const *s, NRMatrix const *m);
300 NRRectL *nr_rect_l_enlarge(NRRectL *d, int amount);
303 #endif /* !LIBNR_NR_RECT_H_SEEN */
305 /*
306 Local Variables:
307 mode:c++
308 c-file-style:"stroustrup"
309 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
310 indent-tabs-mode:nil
311 fill-column:99
312 End:
313 */
314 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :