MrSID Decode SDK for Raster Reference Manual 9.5.4.4709

- Main Page
- Namespaces
- Classes
- Files
- Examples

- File List
- File Members

lti_geometry.h
Go to the documentation of this file.
1 /* $Id$ */
2 /* //////////////////////////////////////////////////////////////////////////
3 // //
4 // This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue, //
5 // Suite 200, Seattle, WA 98104. Unauthorized use or distribution //
6 // prohibited. Access to and use of this code is permitted only under //
7 // license from LizardTech, Inc. Portions of the code are protected by //
8 // US and foreign patents and other filings. All Rights Reserved. //
9 // //
11
12 #ifndef LTI_GEOMETRY_H
13 #define LTI_GEOMETRY_H
14
15 // lt_lib_mrsid_core
16 #include "lti_types.h"
17
18 LT_BEGIN_NAMESPACE(LizardTech)
19
20
21 template<class T>
22 class LTIGeomPoint
23 {
24 public:
25 LTIGeomPoint(T inX = 0, T inY = 0) :
26 x(inX),
27 y(inY)
28 {
29 }
30
31 // ------------------------------
32 // * copy constructor
33 // ------------------------------
34 LTIGeomPoint(const LTIGeomPoint<T>& copy) :
35 x(copy.x),
36 y(copy.y)
37
38 {
39 }
40
41 // ------------------------------
42 // * assignment operator
43 // ------------------------------
44 LTIGeomPoint<T>& operator=(const LTIGeomPoint<T>& copy)
45 {
46 x = copy.x;
47 y = copy.y;
48 return *this;
49 }
50
51
52 // ----------------------------
53 // * addition
54 // ----------------------------
55 template<class T2>
56 LTIGeomPoint<T>& operator +=(const LTIGeomPoint<T2>& offset)
57 {
58 x += offset.x;
59 y += offset.y;
60 return *this;
61 }
62
63 // ----------------------------
64 // * subtraction
65 // ----------------------------
66 template<class T2>
67 LTIGeomPoint<T>& operator -=(const LTIGeomPoint<T2>& offset)
68 {
69 x -= offset.x;
70 y -= offset.y;
71 return *this;
72 }
73
74 // --------------------------------------------------------
75 // * equality operator
76 // --------------------------------------------------------
77 inline bool operator ==(const LTIGeomPoint<T>& other) const
78 {
79 return x == other.x && y == other.y;
80 }
81
82 // --------------------------------------------------------
83 // * not equals operator
84 // --------------------------------------------------------
85 inline bool operator !=(const LTIGeomPoint<T>& other) const
86 {
87 return !operator==(other);
88 }
89
90 inline bool equal(const LTIGeomPoint<T>& other, T eps) const
91 {
92 return (x < other.x ? other.x - x : x - other.x) <= eps &&
93 (y < other.y ? other.y - y : y - other.y) <= eps;
94 }
95
96 public:
97 // --------------------------------------------------------
98 // * Data
99 // --------------------------------------------------------
100 T x;
101 T y;
102 };
103
104
105
106 // --------------------------------------------------------------
107 // * global point operators
108 // --------------------------------------------------------------
109 template<class T>
110 LTIGeomPoint<T> operator+(const LTIGeomPoint<T>& p1, const LTIGeomPoint<T>& p2)
111 {
112 LTIGeomPoint<T> p3 = p1;
113 p3 += p2;
114 return p3;
115 }
116
117 template<class T>
118 LTIGeomPoint<T> operator-(const LTIGeomPoint<T>& p1, const LTIGeomPoint<T>& p2)
119 {
120 LTIGeomPoint<T> p3 = p1;
121 p3 -= p2;
122 return p3;
123 }
124
125
126
127
128 // ----------------------------------------
129 //
130 // Dimensions
131 //
132 // ----------------------------------------
133
134 template<class T>
135 class LTIGeomDim
136 {
137 public:
138 LTIGeomDim(T w = 0, T h = 0) :
139 width(w),
140 height(h)
141 {}
142
143 LTIGeomDim(const LTIGeomDim<T>& other) :
144 width(other.width),
145 height(other.height)
146 {}
147
148 LTIGeomDim<T>& operator=(const LTIGeomDim<T>& other)
149 {
150 width = other.width;
151 height = other.height;
152 return *this;
153 }
154
155 bool operator==(const LTIGeomDim<T>& other) const
156 {
157 return width == other.width && height == other.height;
158 }
159
160 bool operator!=(const LTIGeomDim<T>& other) const
161 {
162 return !operator==(other);
163 }
164
165 public:
166 T width;
167 T height;
168 };
169
170
171
172 // ------------------------------------------------------------
173 //
174 // Rectangles
175 //
176 // The LTIGeomRect class represents rectangles in 2 dimensional space.
177 // A rectangle is defined as having an upper left and a lower right corner.
178 // +X goes to the right and +Y goes down. (It is a left handed world.)
179 //
180 // ------------------------------------------------------------
181
182 template<class T, bool inclusive = true>
183 class LTIGeomRect
184 {
185 public:
186 // ------------------------------------------------------------
187 // * Construct from 2 points
188 // ------------------------------------------------------------
189 LTIGeomRect(const LTIGeomPoint<T>& inUL, const LTIGeomPoint<T>& inLR) :
190 uLeft(inUL),
191 lRight(inLR)
192 {}
193
194 // ------------------------------------------------------------
195 // * Construct from 4 values - the first pair is upper left,
196 // second pair is lower right
197 // ------------------------------------------------------------
198 LTIGeomRect(T ulx=0, T uly=1, T lrx=-1, T lry=0) :
199 uLeft(ulx, uly),
200 lRight(lrx, lry)
201 {}
202
203
204 // ------------------------------------------------------------
205 // * Construct from a dimension
206 // Resulting rect has uLeft = (0,0) and dimensions d
207 // ------------------------------------------------------------
208 LTIGeomRect(const LTIGeomDim<T> d) :
209 uLeft(0,0),
210 lRight(d.width - (inclusive ? 1 : 0), d.height - (inclusive ? 1 : 0))
211 {}
212
213 // ------------------------------------------------------------
214 // * Copy constructor
215 // ------------------------------------------------------------
216 LTIGeomRect(const LTIGeomRect<T, inclusive>& copy) :
217 uLeft(copy.uLeft),
218 lRight(copy.lRight)
219 {}
220
221 // ------------------------------------------------------------
222 // * Assignment operator
223 // ------------------------------------------------------------
224 LTIGeomRect<T, inclusive>& operator=(const LTIGeomRect<T, inclusive>& copy)
225 {
226 uLeft = copy.uLeft;
227 lRight = copy.lRight;
228 return *this;
229 }
230
231 // ------------------------------------------------------------
232 // * width
233 // ------------------------------------------------------------
234 T getWidth() const
235 {
236 return (lRight.x - uLeft.x) + (T)(inclusive ? 1 : 0);
237 }
238 T width() const { return getWidth(); } // BUG: api change
239
240 // ------------------------------------------------------------
241 // * height
242 // ------------------------------------------------------------
243 T getHeight() const
244 {
245 return (lRight.y - uLeft.y) + (T)(inclusive ? 1 : 0);
246 }
247 T height() const { return getHeight(); } // BUG: api change
248
249 // ------------------------------------------------------------
250 // * isEmpty
251 // ------------------------------------------------------------
252 bool isEmpty() const
253 {
254 return getWidth() <= 0 || getHeight() <= 0;
255 }
256
257 // ------------------------------------------------------------
258 // * dimensions
259 // ------------------------------------------------------------
260 LTIGeomDim<T> getDimensions() const
261 {
262 return LTIGeomDim<T>(getWidth(), getHeight());
263 }
264
265 // ------------------------------------------------------------
266 // * returns center point of the rectangle
267 // ------------------------------------------------------------
268 LTIGeomPoint<T> getCenter() const
269 {
270 T cx = uLeft.x + getWidth()/2;
271 T cy = uLeft.y + getHeight()/2;
272 return LTIGeomPoint<T>(cx, cy);
273 }
274
275
276 // ------------------------------------------------------------
277 // * location
278 // returns the location of the specified reference point
279 // ------------------------------------------------------------
280 LTIGeomPoint<T> location(LTIPosition referencePoint)
281 {
282 LTIGeomPoint<T> ref = uLeft;
283 switch (referencePoint)
284 {
285 case LTI_POSITION_UPPER_LEFT:
286 break;
287 case LTI_POSITION_UPPER_CENTER:
288 ref.x += static_cast<T>(getWidth()/2.0);
289 break;
290 case LTI_POSITION_UPPER_RIGHT:
291 ref.x = static_cast<T>(lRight.x);
292 break;
293
294 case LTI_POSITION_CENTER_LEFT:
295 ref.y -= static_cast<T>(-getHeight()/2.0);
296 break;
297 case LTI_POSITION_CENTER:
298 ref.x += static_cast<T>(getWidth()/2.0);
299 ref.y -= static_cast<T>(-getHeight()/2.0);
300 break;
301 case LTI_POSITION_CENTER_RIGHT:
302 ref.x = static_cast<T>(lRight.x);
303 ref.y -= static_cast<T>(-getHeight()/2.0);
304 break;
305
306 case LTI_POSITION_LOWER_LEFT:
307 ref.y = static_cast<T>(lRight.y);
308 break;
309 case LTI_POSITION_LOWER_CENTER:
310 ref.y = static_cast<T>(lRight.y);
311 ref.x += static_cast<T>(getWidth()/2.0);
312 break;
313 case LTI_POSITION_LOWER_RIGHT:
314 ref = lRight;
315 break;
316 }
317 return ref;
318 }
319
320
321 // ------------------------------------------------------------
322 // * addition
323 // moves the restangle by an offset
324 // ------------------------------------------------------------
325 template<class T2>
326 LTIGeomRect<T, inclusive>& operator+=(const LTIGeomPoint<T2>& offset)
327 {
328 uLeft += offset;
329 lRight += offset;
330 return *this;
331 }
332
333 // ------------------------------------------------------------
334 // * subtraction
335 // moves the restangle by an offset
336 // ------------------------------------------------------------
337 template<class T2>
338 LTIGeomRect<T, inclusive>& operator-=(const LTIGeomPoint<T2>& offset)
339 {
340 uLeft -= offset;
341 lRight -= offset;
342 return *this;
343 }
344
345 // ------------------------------------------------------------
346 // * intersection operator
347 // returns the intersection between two rectangles
348 // ------------------------------------------------------------
349 LTIGeomRect<T, inclusive>& operator &=(const LTIGeomRect<T, inclusive>& other)
350 {
351 if(!intersect(other))
352 *this = LTIGeomRect(); // invalid rectangle
353 return *this;
354 }
355
356 // ------------------------------------------------------------
357 // * union operator
358 // returns the union of two rectangles
359 // ------------------------------------------------------------
360 LTIGeomRect<T, inclusive>& operator |=(const LTIGeomRect<T, inclusive>& other)
361 {
362 uLeft.x = LT_MIN(uLeft.x, other.uLeft.x);
363 uLeft.y = LT_MIN(uLeft.y, other.uLeft.y);
364 lRight.x = LT_MAX(lRight.x, other.lRight.x);
365 lRight.y = LT_MAX(lRight.y, other.lRight.y);
366 return *this;
367 }
368
369 bool operator==(const LTIGeomRect<T, inclusive>& other) const
370 {
371 return uLeft == other.uLeft && lRight == other.lRight;
372 }
373
374 // --------------------------------------------------------
375 // * not equals operator
376 // --------------------------------------------------------
377 inline bool operator !=(const LTIGeomRect<T, inclusive>& other) const
378 {
379 return !operator==(other);
380 };
381
382 // clip our rectangle to the given size, i.e. do an intersection
383 // return true iff we remain a valid rectangle
384 bool intersect(const LTIGeomRect<T, inclusive>& other)
385 {
386 uLeft.x = LT_MAX(uLeft.x, other.uLeft.x);
387 uLeft.y = LT_MAX(uLeft.y, other.uLeft.y);
388 lRight.x = LT_MIN(lRight.x, other.lRight.x);
389 lRight.y = LT_MIN(lRight.y, other.lRight.y);
390
391 return uLeft.x <= lRight.x && uLeft.y <= lRight.y;
392 }
393
394 public:
395 // ------------------------------------------------
396 // * Data
397 // ------------------------------------------------
398 LTIGeomPoint<T> uLeft; // upper left corner
399 LTIGeomPoint<T> lRight; // lower right corner
400 };
401
402
403 // --------------------------------------------------------------
404 // * global rect operators
405 // --------------------------------------------------------------
406 template<class T, bool inclusive>
407 LTIGeomRect<T, inclusive> operator+(const LTIGeomRect<T, inclusive>& r1,
408 const LTIGeomPoint<T>& offset)
409 {
410 LTIGeomRect<T, inclusive> r3 = r1;
411 r3 += offset;
412 return r3;
413 }
414
415 template<class T, bool inclusive>
416 LTIGeomRect<T, inclusive> operator-(const LTIGeomRect<T, inclusive>& r1,
417 const LTIGeomPoint<T>& offset)
418 {
419 LTIGeomRect<T, inclusive> r3 = r1;
420 r3 -= offset;
421 return r3;
422 }
423
424 template<class T, bool inclusive>
425 LTIGeomRect<T, inclusive> operator&(const LTIGeomRect<T, inclusive>& r1,
426 const LTIGeomRect<T, inclusive>& r2)
427 {
428 LTIGeomRect<T, inclusive> r3 = r1;
429 r3 &= r2;
430 return r3;
431 }
432
433 template<class T, bool inclusive>
434 LTIGeomRect<T, inclusive> operator|(const LTIGeomRect<T, inclusive>& r1,
435 const LTIGeomRect<T, inclusive>& r2)
436 {
437 LTIGeomRect<T, inclusive> r3 = r1;
438 r3 |= r2;
439 return r3;
440 }
441
442
443 // ------------------------------------------------------------
444 //
445 // Bound Box
446 //
447 // The LTIGeomBBox class represents rectangles in 2 dimensional space.
448 // A rectangle is defined as having a min point and a max point.
449 // +X goes to the right and +Y goes up. (It is a right handed world.)
450 //
451 // ------------------------------------------------------------
452
453 template<class T>
454 class LTIGeomBBox
455 {
456 public:
457 LTIGeomBBox(T minX = 0, T minY = 0, T maxX = 0, T maxY = 0) :
458 xMin(minX),
459 yMin(minY),
460 xMax(maxX),
461 yMax(maxY)
462 {}
463
464 LTIGeomBBox(const LTIGeomBBox<T>& copy) :
465 xMin(copy.xMin),
466 yMin(copy.yMin),
467 xMax(copy.xMax),
468 yMax(copy.yMax)
469 {}
470
471 LTIGeomBBox<T>& operator=(const LTIGeomBBox<T>& copy)
472 {
473 xMin = copy.xMin;
474 yMin = copy.yMin;
475 xMax = copy.xMax;
476 yMax = copy.yMax;
477 return *this;
478 }
479
480 T getWidth() const { return xMax - xMin; }
481 T getHeight() const { return yMax - yMin; }
482 bool isEmpty() const { return xMax <= xMin || yMax <= yMin; }
483 LTIGeomPoint<T> getCenter() const
484 {
485 return LTIGeomPoint<T>((xMin + xMax) / 2, (yMin + yMax) / 2);
486 }
487
488 // intersection operator
489 LTIGeomBBox<T>& operator &=(const LTIGeomBBox<T>& other)
490 {
491 xMin = LT_MAX(xMin, other.xMin);
492 yMin = LT_MAX(yMin, other.yMin);
493 xMax = LT_MIN(xMax, other.xMax);
494 yMax = LT_MIN(yMax, other.yMax);
495 return *this;
496 }
497
498 // union operator
499 LTIGeomBBox<T>& operator |=(const LTIGeomBBox<T>& other)
500 {
501 xMin = LT_MIN(xMin, other.xMin);
502 yMin = LT_MIN(yMin, other.yMin);
503 xMax = LT_MAX(xMax, other.xMax);
504 yMax = LT_MAX(yMax, other.yMax);
505 return *this;
506 }
507
508 bool overlap(const LTIGeomBBox<T>& other) const
509 {
510 if(xMin > other.xMax || other.xMin > xMax)
511 return false;
512 if(yMin > other.yMax || other.yMin > yMax)
513 return false;
514 return true;
515 }
516
517 bool containsPoint(const LTIGeomPoint<T> &pt) const
518 {
519 return (xMin <= pt.x && pt.x <= xMax) &&
520 (yMin <= pt.y && pt.y <= yMax);
521 }
522
523 // equalty operators
524 bool operator ==(const LTIGeomBBox<T>& other) const
525 {
526 return xMin == other.xMin &&
527 yMin == other.yMin &&
528 xMax == other.xMax &&
529 yMax == other.yMax;
530 }
531 bool operator !=(const LTIGeomBBox<T>& other) const
532 {
533 return !operator==(other);
534 }
535
536 public:
537 T xMin;
538 T yMin;
539 T xMax;
540 T yMax;
541 };
542
543 typedef LTIGeomRect<lt_int32, true> LTIGeomIntRect;
544 typedef LTIGeomDim<lt_int32> LTIGeomIntDim;
545 typedef LTIGeomPoint<lt_int32> LTIGeomIntPoint;
546
547 typedef LTIGeomRect<double, false> LTIGeomDblRect;
548 typedef LTIGeomDim<double> LTIGeomDblDim;
549 typedef LTIGeomPoint<double> LTIGeomDblPoint;
550
551 // BUG: these just for backwards compatability (mg3)
552 typedef LTIGeomRect<lt_int32, true> MG3Rect;
553 typedef LTIGeomDim<lt_int32> MG3Dim;
554 typedef LTIGeomPoint<lt_int32> MG3Point;
555
556 // BUG: these just for backwards compatability (mg2)
557 typedef LTIGeomRect<lt_int32, true> IntRect;
558 typedef LTIGeomDim<lt_int32> IntDimension;
559 typedef LTIGeomPoint<lt_int32> IntPoint;
560
561 LT_END_NAMESPACE(LizardTech)
562
563
564 #endif // LTI_GEOMETRY_H

LizardTech