FLImaging 6.5.8.1
TRange.h
1#pragma once
2
11#include "FLLibTags.h"
12#include "TPoint.h"
13#include "TRect.h"
14
16namespace FLImaging
17{
19 namespace Base
20 {
32 #pragma pack(push, 1)
33 template <typename T>
34 class FL_EXPORT TRange
35 {
36 public:
37 TPoint<T> tpPoints[2];
38
39
40 TRange()
41 {
42 }
43
44 TRange(T tLBX, T tLBY, T tUBX, T tUBY)
45 {
46 tpPoints[0].x = tLBX;
47 tpPoints[0].y = tLBY;
48 tpPoints[1].x = tUBX;
49 tpPoints[1].y = tUBY;
50 }
51
52 TRange(const TRect<T>& tr)
53 {
54 tpPoints[0].x = tr.left;
55 tpPoints[0].y = tr.top;
56 tpPoints[1].x = tr.right;
57 tpPoints[1].y = tr.bottom;
58 }
59
60 TRange(const TRange<int16_t>& tr)
61 {
62 tpPoints[0].Set(tr.tpPoints[0]);
63 tpPoints[1].Set(tr.tpPoints[1]);
64 }
65
66 TRange(const TRange<int16_t>* pTr)
67 {
68 if(pTr)
69 {
70 tpPoints[0].Set(pTr->tpPoints[0]);
71 tpPoints[1].Set(pTr->tpPoints[1]);
72 }
73 }
74
75 TRange(const TRange<uint16_t>& tr)
76 {
77 tpPoints[0].Set(tr.tpPoints[0]);
78 tpPoints[1].Set(tr.tpPoints[1]);
79 }
80
81 TRange(const TRange<uint16_t>* pTr)
82 {
83 if(pTr)
84 {
85 tpPoints[0].Set(pTr->tpPoints[0]);
86 tpPoints[1].Set(pTr->tpPoints[1]);
87 }
88 }
89
90 TRange(const TRange<int32_t>& tr)
91 {
92 tpPoints[0].Set(tr.tpPoints[0]);
93 tpPoints[1].Set(tr.tpPoints[1]);
94 }
95
96 TRange(const TRange<int32_t>* pTr)
97 {
98 if(pTr)
99 {
100 tpPoints[0].Set(pTr->tpPoints[0]);
101 tpPoints[1].Set(pTr->tpPoints[1]);
102 }
103 }
104
105 TRange(const TRange<uint32_t>& tr)
106 {
107 tpPoints[0].Set(tr.tpPoints[0]);
108 tpPoints[1].Set(tr.tpPoints[1]);
109 }
110
111 TRange(const TRange<uint32_t>* pTr)
112 {
113 if(pTr)
114 {
115 tpPoints[0].Set(pTr->tpPoints[0]);
116 tpPoints[1].Set(pTr->tpPoints[1]);
117 }
118 }
119
120 TRange(const TRange<int64_t>& tr)
121 {
122 tpPoints[0].Set(tr.tpPoints[0]);
123 tpPoints[1].Set(tr.tpPoints[1]);
124 }
125
126 TRange(const TRange<int64_t>* pTr)
127 {
128 if(pTr)
129 {
130 tpPoints[0].Set(pTr->tpPoints[0]);
131 tpPoints[1].Set(pTr->tpPoints[1]);
132 }
133 }
134
135 TRange(const TRange<uint64_t>& tr)
136 {
137 tpPoints[0].Set(tr.tpPoints[0]);
138 tpPoints[1].Set(tr.tpPoints[1]);
139 }
140
141 TRange(const TRange<uint64_t>* pTr)
142 {
143 if(pTr)
144 {
145 tpPoints[0].Set(pTr->tpPoints[0]);
146 tpPoints[1].Set(pTr->tpPoints[1]);
147 }
148 }
149
150 TRange(const TRange<float>& tr)
151 {
152 tpPoints[0].Set(tr.tpPoints[0]);
153 tpPoints[1].Set(tr.tpPoints[1]);
154 }
155
156 TRange(const TRange<float>* pTr)
157 {
158 if(pTr)
159 {
160 tpPoints[0].Set(pTr->tpPoints[0]);
161 tpPoints[1].Set(pTr->tpPoints[1]);
162 }
163 }
164
165 TRange(const TRange<double>& tr)
166 {
167 tpPoints[0].Set(tr.tpPoints[0]);
168 tpPoints[1].Set(tr.tpPoints[1]);
169 }
170
171 TRange(const TRange<double>* pTr)
172 {
173 if(pTr)
174 {
175 tpPoints[0].Set(pTr->tpPoints[0]);
176 tpPoints[1].Set(pTr->tpPoints[1]);
177 }
178 }
179
180 TRange(const TPoint<int16_t>& tpLB, const TPoint<int16_t>& tpUB)
181 {
182 tpPoints[0].Set(tpLB);
183 tpPoints[1].Set(tpUB);
184 }
185
186 TRange(const TPoint<int16_t>* pTpLB, const TPoint<int16_t>* pTpUB)
187 {
188 if(pTpLB && pTpUB)
189 {
190 tpPoints[0].Set(pTpLB);
191 tpPoints[1].Set(pTpUB);
192 }
193 }
194
195 TRange(const TPoint<uint16_t>& tpLB, const TPoint<uint16_t>& tpUB)
196 {
197 tpPoints[0].Set(tpLB);
198 tpPoints[1].Set(tpUB);
199 }
200
201 TRange(const TPoint<uint16_t>* pTpLB, const TPoint<uint16_t>* pTpUB)
202 {
203 if(pTpLB && pTpUB)
204 {
205 tpPoints[0].Set(pTpLB);
206 tpPoints[1].Set(pTpUB);
207 }
208 }
209
210 TRange(const TPoint<int32_t>& tpLB, const TPoint<int32_t>& tpUB)
211 {
212 tpPoints[0].Set(tpLB);
213 tpPoints[1].Set(tpUB);
214 }
215
216 TRange(const TPoint<int32_t>* pTpLB, const TPoint<int32_t>* pTpUB)
217 {
218 if(pTpLB && pTpUB)
219 {
220 tpPoints[0].Set(pTpLB);
221 tpPoints[1].Set(pTpUB);
222 }
223 }
224
225 TRange(const TPoint<uint32_t>& tpLB, const TPoint<uint32_t>& tpUB)
226 {
227 tpPoints[0].Set(tpLB);
228 tpPoints[1].Set(tpUB);
229 }
230
231 TRange(const TPoint<uint32_t>* pTpLB, const TPoint<uint32_t>* pTpUB)
232 {
233 if(pTpLB && pTpUB)
234 {
235 tpPoints[0].Set(pTpLB);
236 tpPoints[1].Set(pTpUB);
237 }
238 }
239
240 TRange(const TPoint<int64_t>& tpLB, const TPoint<int64_t>& tpUB)
241 {
242 tpPoints[0].Set(tpLB);
243 tpPoints[1].Set(tpUB);
244 }
245
246 TRange(const TPoint<int64_t>* pTpLB, const TPoint<int64_t>* pTpUB)
247 {
248 if(pTpLB && pTpUB)
249 {
250 tpPoints[0].Set(pTpLB);
251 tpPoints[1].Set(pTpUB);
252 }
253 }
254
255 TRange(const TPoint<uint64_t>& tpLB, const TPoint<uint64_t>& tpUB)
256 {
257 tpPoints[0].Set(tpLB);
258 tpPoints[1].Set(tpUB);
259 }
260
261 TRange(const TPoint<uint64_t>* pTpLB, const TPoint<uint64_t>* pTpUB)
262 {
263 if(pTpLB && pTpUB)
264 {
265 tpPoints[0].Set(pTpLB);
266 tpPoints[1].Set(pTpUB);
267 }
268 }
269
270 TRange(const TPoint<float>& tpLB, const TPoint<float>& tpUB)
271 {
272 tpPoints[0].Set(tpLB);
273 tpPoints[1].Set(tpUB);
274 }
275
276 TRange(const TPoint<float>* pTpLB, const TPoint<float>* pTpUB)
277 {
278 if(pTpLB && pTpUB)
279 {
280 tpPoints[0].Set(pTpLB);
281 tpPoints[1].Set(pTpUB);
282 }
283 }
284
285 TRange(const TPoint<double>& tpLB, const TPoint<double>& tpUB)
286 {
287 tpPoints[0].Set(tpLB);
288 tpPoints[1].Set(tpUB);
289 }
290
291 TRange(const TPoint<double>* pTpLB, const TPoint<double>* pTpUB)
292 {
293 if(pTpLB && pTpUB)
294 {
295 tpPoints[0].Set(pTpLB);
296 tpPoints[1].Set(pTpUB);
297 }
298 }
299
300
301 void Set(T tLBX, T tLBY, T tUBX, T tUBY)
302 {
303 tpPoints[0].x = tLBX;
304 tpPoints[0].y = tLBY;
305 tpPoints[1].x = tUBX;
306 tpPoints[1].y = tUBY;
307 }
308
309 void Set(const TRect<T>& tr)
310 {
311 tpPoints[0].x = tr.left;
312 tpPoints[0].y = tr.top;
313 tpPoints[1].x = tr.right;
314 tpPoints[1].y = tr.bottom;
315 }
316
317 void Set(const TRange<int16_t>& tr)
318 {
319 tpPoints[0].Set(tr.tpPoints[0]);
320 tpPoints[1].Set(tr.tpPoints[1]);
321 }
322
323 void Set(const TRange<int16_t>* pTr)
324 {
325 if(pTr)
326 {
327 tpPoints[0].Set(pTr->tpPoints[0]);
328 tpPoints[1].Set(pTr->tpPoints[1]);
329 }
330 }
331
332 void Set(const TRange<uint16_t>& tr)
333 {
334 tpPoints[0].Set(tr.tpPoints[0]);
335 tpPoints[1].Set(tr.tpPoints[1]);
336 }
337
338 void Set(const TRange<uint16_t>* pTr)
339 {
340 if(pTr)
341 {
342 tpPoints[0].Set(pTr->tpPoints[0]);
343 tpPoints[1].Set(pTr->tpPoints[1]);
344 }
345 }
346
347 void Set(const TRange<int32_t>& tr)
348 {
349 tpPoints[0].Set(tr.tpPoints[0]);
350 tpPoints[1].Set(tr.tpPoints[1]);
351 }
352
353 void Set(const TRange<int32_t>* pTr)
354 {
355 if(pTr)
356 {
357 tpPoints[0].Set(pTr->tpPoints[0]);
358 tpPoints[1].Set(pTr->tpPoints[1]);
359 }
360 }
361
362 void Set(const TRange<uint32_t>& tr)
363 {
364 tpPoints[0].Set(tr.tpPoints[0]);
365 tpPoints[1].Set(tr.tpPoints[1]);
366 }
367
368 void Set(const TRange<uint32_t>* pTr)
369 {
370 if(pTr)
371 {
372 tpPoints[0].Set(pTr->tpPoints[0]);
373 tpPoints[1].Set(pTr->tpPoints[1]);
374 }
375 }
376
377 void Set(const TRange<int64_t>& tr)
378 {
379 tpPoints[0].Set(tr.tpPoints[0]);
380 tpPoints[1].Set(tr.tpPoints[1]);
381 }
382
383 void Set(const TRange<int64_t>* pTr)
384 {
385 if(pTr)
386 {
387 tpPoints[0].Set(pTr->tpPoints[0]);
388 tpPoints[1].Set(pTr->tpPoints[1]);
389 }
390 }
391
392 void Set(const TRange<uint64_t>& tr)
393 {
394 tpPoints[0].Set(tr.tpPoints[0]);
395 tpPoints[1].Set(tr.tpPoints[1]);
396 }
397
398 void Set(const TRange<uint64_t>* pTr)
399 {
400 if(pTr)
401 {
402 tpPoints[0].Set(pTr->tpPoints[0]);
403 tpPoints[1].Set(pTr->tpPoints[1]);
404 }
405 }
406
407 void Set(const TRange<float>& tr)
408 {
409 tpPoints[0].Set(tr.tpPoints[0]);
410 tpPoints[1].Set(tr.tpPoints[1]);
411 }
412
413 void Set(const TRange<float>* pTr)
414 {
415 if(pTr)
416 {
417 tpPoints[0].Set(pTr->tpPoints[0]);
418 tpPoints[1].Set(pTr->tpPoints[1]);
419 }
420 }
421
422 void Set(const TRange<double>& tr)
423 {
424 tpPoints[0].Set(tr.tpPoints[0]);
425 tpPoints[1].Set(tr.tpPoints[1]);
426 }
427
428 void Set(const TRange<double>* pTr)
429 {
430 if(pTr)
431 {
432 tpPoints[0].Set(pTr->tpPoints[0]);
433 tpPoints[1].Set(pTr->tpPoints[1]);
434 }
435 }
436
437 void Set(const TPoint<int16_t>& tpLB, const TPoint<int16_t>& tpUB)
438 {
439 tpPoints[0].Set(tpLB);
440 tpPoints[1].Set(tpUB);
441 }
442
443 void Set(const TPoint<int16_t>* pTpLB, const TPoint<int16_t>* pTpUB)
444 {
445 if(pTpLB && pTpUB)
446 {
447 tpPoints[0].Set(pTpLB);
448 tpPoints[1].Set(pTpUB);
449 }
450 }
451
452 void Set(const TPoint<uint16_t>& tpLB, const TPoint<uint16_t>& tpUB)
453 {
454 tpPoints[0].Set(tpLB);
455 tpPoints[1].Set(tpUB);
456 }
457
458 void Set(const TPoint<uint16_t>* pTpLB, const TPoint<uint16_t>* pTpUB)
459 {
460 if(pTpLB && pTpUB)
461 {
462 tpPoints[0].Set(pTpLB);
463 tpPoints[1].Set(pTpUB);
464 }
465 }
466
467 void Set(const TPoint<int32_t>& tpLB, const TPoint<int32_t>& tpUB)
468 {
469 tpPoints[0].Set(tpLB);
470 tpPoints[1].Set(tpUB);
471 }
472
473 void Set(const TPoint<int32_t>* pTpLB, const TPoint<int32_t>* pTpUB)
474 {
475 if(pTpLB && pTpUB)
476 {
477 tpPoints[0].Set(pTpLB);
478 tpPoints[1].Set(pTpUB);
479 }
480 }
481
482 void Set(const TPoint<uint32_t>& tpLB, const TPoint<uint32_t>& tpUB)
483 {
484 tpPoints[0].Set(tpLB);
485 tpPoints[1].Set(tpUB);
486 }
487
488 void Set(const TPoint<uint32_t>* pTpLB, const TPoint<uint32_t>* pTpUB)
489 {
490 if(pTpLB && pTpUB)
491 {
492 tpPoints[0].Set(pTpLB);
493 tpPoints[1].Set(pTpUB);
494 }
495 }
496
497 void Set(const TPoint<int64_t>& tpLB, const TPoint<int64_t>& tpUB)
498 {
499 tpPoints[0].Set(tpLB);
500 tpPoints[1].Set(tpUB);
501 }
502
503 void Set(const TPoint<int64_t>* pTpLB, const TPoint<int64_t>* pTpUB)
504 {
505 if(pTpLB && pTpUB)
506 {
507 tpPoints[0].Set(pTpLB);
508 tpPoints[1].Set(pTpUB);
509 }
510 }
511
512 void Set(const TPoint<uint64_t>& tpLB, const TPoint<uint64_t>& tpUB)
513 {
514 tpPoints[0].Set(tpLB);
515 tpPoints[1].Set(tpUB);
516 }
517
518 void Set(const TPoint<uint64_t>* pTpLB, const TPoint<uint64_t>* pTpUB)
519 {
520 if(pTpLB && pTpUB)
521 {
522 tpPoints[0].Set(pTpLB);
523 tpPoints[1].Set(pTpUB);
524 }
525 }
526
527 void Set(const TPoint<float>& tpLB, const TPoint<float>& tpUB)
528 {
529 tpPoints[0].Set(tpLB);
530 tpPoints[1].Set(tpUB);
531 }
532
533 void Set(const TPoint<float>* pTpLB, const TPoint<float>* pTpUB)
534 {
535 if(pTpLB && pTpUB)
536 {
537 tpPoints[0].Set(pTpLB);
538 tpPoints[1].Set(pTpUB);
539 }
540 }
541
542 void Set(const TPoint<double>& tpLB, const TPoint<double>& tpUB)
543 {
544 tpPoints[0].Set(tpLB);
545 tpPoints[1].Set(tpUB);
546 }
547
548 void Set(const TPoint<double>* pTpLB, const TPoint<double>* pTpUB)
549 {
550 if(pTpLB && pTpUB)
551 {
552 tpPoints[0].Set(pTpLB);
553 tpPoints[1].Set(pTpUB);
554 }
555 }
556
557
558 const TRange<T>& operator=(int32_t value)
559 {
560 tpPoints[0] = value;
561 tpPoints[1] = value;
562
563 return *this;
564 }
565
566 const TRange<T>& operator=(int64_t value)
567 {
568 tpPoints[0] = value;
569 tpPoints[1] = value;
570
571 return *this;
572 }
573
574 const TRange<T>& operator=(float value)
575 {
576 tpPoints[0] = value;
577 tpPoints[1] = value;
578
579 return *this;
580 }
581
582 const TRange<T>& operator=(double value)
583 {
584 tpPoints[0] = value;
585 tpPoints[1] = value;
586
587 return *this;
588 }
589
590 const TRange<T>& operator=(const TRange<int32_t>& tr)
591 {
592 Set(tr);
593
594 return *this;
595 }
596
597 const TRange<T>& operator=(const TRange<int64_t>& tr)
598 {
599 Set(tr);
600
601 return *this;
602 }
603
604 const TRange<T>& operator=(const TRange<float>& tr)
605 {
606 Set(tr);
607
608 return *this;
609 }
610
611 const TRange<T>& operator=(const TRange<double>& tr)
612 {
613 Set(tr);
614
615 return *this;
616 }
617
618 bool operator==(const TRange<int32_t>& tr)
619 {
620 return tpPoints[0] == tr.tpPoints[0] && tpPoints[1] == tr.tpPoints[1];
621 }
622
623 bool operator==(const TRange<int64_t>& tr)
624 {
625 return tpPoints[0] == tr.tpPoints[0] && tpPoints[1] == tr.tpPoints[1];
626 }
627
628 bool operator==(const TRange<float>& tr)
629 {
630 return tpPoints[0] == tr.tpPoints[0] && tpPoints[1] == tr.tpPoints[1];
631 }
632
633 bool operator==(const TRange<double>& tr)
634 {
635 return tpPoints[0] == tr.tpPoints[0] && tpPoints[1] == tr.tpPoints[1];
636 }
637
638 bool operator!=(const TRange<int32_t>& tr)
639 {
640 return tpPoints[0] != tr.tpPoints[0] || tpPoints[1] != tr.tpPoints[1];
641 }
642
643 bool operator!=(const TRange<int64_t>& tr)
644 {
645 return tpPoints[0] != tr.tpPoints[0] || tpPoints[1] != tr.tpPoints[1];
646 }
647
648 bool operator!=(const TRange<float>& tr)
649 {
650 return tpPoints[0] != tr.tpPoints[0] || tpPoints[1] != tr.tpPoints[1];
651 }
652
653 bool operator!=(const TRange<double>& tr)
654 {
655 return tpPoints[0] != tr.tpPoints[0] || tpPoints[1] != tr.tpPoints[1];
656 }
657
658 const TRange<T>& operator+=(int32_t value)
659 {
660 tpPoints[0] += value;
661 tpPoints[1] += value;
662
663 return *this;
664 }
665
666 const TRange<T>& operator+=(int64_t value)
667 {
668 tpPoints[0] += value;
669 tpPoints[1] += value;
670
671 return *this;
672 }
673
674 const TRange<T>& operator+=(float value)
675 {
676 tpPoints[0] += value;
677 tpPoints[1] += value;
678
679 return *this;
680 }
681
682 const TRange<T>& operator+=(double value)
683 {
684 tpPoints[0] += value;
685 tpPoints[1] += value;
686
687 return *this;
688 }
689
690 const TRange<T>& operator+=(const TRange<int32_t>& tr)
691 {
692 tpPoints[0] += tr.tpPoints[0];
693 tpPoints[1] += tr.tpPoints[1];
694
695 return *this;
696 }
697
698 const TRange<T>& operator+=(const TRange<int64_t>& tr)
699 {
700 tpPoints[0] += tr.tpPoints[0];
701 tpPoints[1] += tr.tpPoints[1];
702
703 return *this;
704 }
705
706 const TRange<T>& operator+=(const TRange<float>& tr)
707 {
708 tpPoints[0] += tr.tpPoints[0];
709 tpPoints[1] += tr.tpPoints[1];
710
711 return *this;
712 }
713
714 const TRange<T>& operator+=(const TRange<double>& tr)
715 {
716 tpPoints[0] += tr.tpPoints[0];
717 tpPoints[1] += tr.tpPoints[1];
718
719 return *this;
720 }
721
722 const TRange<T>& operator-=(int32_t value)
723 {
724 tpPoints[0] -= value;
725 tpPoints[1] -= value;
726
727 return *this;
728 }
729
730 const TRange<T>& operator-=(int64_t value)
731 {
732 tpPoints[0] -= value;
733 tpPoints[1] -= value;
734
735 return *this;
736 }
737
738 const TRange<T>& operator-=(float value)
739 {
740 tpPoints[0] -= value;
741 tpPoints[1] -= value;
742
743 return *this;
744 }
745
746 const TRange<T>& operator-=(double value)
747 {
748 tpPoints[0] -= value;
749 tpPoints[1] -= value;
750
751 return *this;
752 }
753
754 const TRange<T>& operator-=(const TRange<int32_t>& tr)
755 {
756 tpPoints[0] -= tr.tpPoints[0];
757 tpPoints[1] -= tr.tpPoints[1];
758
759 return *this;
760 }
761
762 const TRange<T>& operator-=(const TRange<int64_t>& tr)
763 {
764 tpPoints[0] -= tr.tpPoints[0];
765 tpPoints[1] -= tr.tpPoints[1];
766
767 return *this;
768 }
769
770 const TRange<T>& operator-=(const TRange<float>& tr)
771 {
772 tpPoints[0] -= tr.tpPoints[0];
773 tpPoints[1] -= tr.tpPoints[1];
774
775 return *this;
776 }
777
778 const TRange<T>& operator-=(const TRange<double>& tr)
779 {
780 tpPoints[0] -= tr.tpPoints[0];
781 tpPoints[1] -= tr.tpPoints[1];
782
783 return *this;
784 }
785
786 const TRange<T>& operator*=(int32_t value)
787 {
788 tpPoints[0] *= value;
789 tpPoints[1] *= value;
790
791 return *this;
792 }
793
794 const TRange<T>& operator*=(int64_t value)
795 {
796 tpPoints[0] *= value;
797 tpPoints[1] *= value;
798
799 return *this;
800 }
801
802 const TRange<T>& operator*=(float value)
803 {
804 tpPoints[0] *= value;
805 tpPoints[1] *= value;
806
807 return *this;
808 }
809
810 const TRange<T>& operator*=(double value)
811 {
812 tpPoints[0] *= value;
813 tpPoints[1] *= value;
814
815 return *this;
816 }
817
818 const TRange<T>& operator*=(const TRange<int32_t>& tr)
819 {
820 tpPoints[0] *= tr.tpPoints[0];
821 tpPoints[1] *= tr.tpPoints[1];
822
823 return *this;
824 }
825
826 const TRange<T>& operator*=(const TRange<int64_t>& tr)
827 {
828 tpPoints[0] *= tr.tpPoints[0];
829 tpPoints[1] *= tr.tpPoints[1];
830
831 return *this;
832 }
833
834 const TRange<T>& operator*=(const TRange<float>& tr)
835 {
836 tpPoints[0] *= tr.tpPoints[0];
837 tpPoints[1] *= tr.tpPoints[1];
838
839 return *this;
840 }
841
842 const TRange<T>& operator*=(const TRange<double>& tr)
843 {
844 tpPoints[0] *= tr.tpPoints[0];
845 tpPoints[1] *= tr.tpPoints[1];
846
847 return *this;
848 }
849
850 const TRange<T>& operator/=(int32_t value)
851 {
852 tpPoints[0] /= value;
853 tpPoints[1] /= value;
854
855 return *this;
856 }
857
858 const TRange<T>& operator/=(int64_t value)
859 {
860 tpPoints[0] /= value;
861 tpPoints[1] /= value;
862
863 return *this;
864 }
865
866 const TRange<T>& operator/=(float value)
867 {
868 tpPoints[0] /= value;
869 tpPoints[1] /= value;
870
871 return *this;
872 }
873
874 const TRange<T>& operator/=(double value)
875 {
876 tpPoints[0] /= value;
877 tpPoints[1] /= value;
878
879 return *this;
880 }
881
882 const TRange<T>& operator/=(const TRange<int32_t>& tr)
883 {
884 tpPoints[0] /= tr.tpPoints[0];
885 tpPoints[1] /= tr.tpPoints[1];
886
887 return *this;
888 }
889
890 const TRange<T>& operator/=(const TRange<int64_t>& tr)
891 {
892 tpPoints[0] /= tr.tpPoints[0];
893 tpPoints[1] /= tr.tpPoints[1];
894
895 return *this;
896 }
897
898 const TRange<T>& operator/=(const TRange<float>& tr)
899 {
900 tpPoints[0] /= tr.tpPoints[0];
901 tpPoints[1] /= tr.tpPoints[1];
902
903 return *this;
904 }
905
906 const TRange<T>& operator/=(const TRange<double>& tr)
907 {
908 tpPoints[0] /= tr.tpPoints[0];
909 tpPoints[1] /= tr.tpPoints[1];
910
911 return *this;
912 }
913
914 TRange<T> operator+(int32_t value)
915 {
916 TRange<T> trReturn(this);
917 trReturn += value;
918 return trReturn;
919 }
920
921 TRange<T> operator+(int64_t value)
922 {
923 TRange<T> trReturn(this);
924 trReturn += value;
925 return trReturn;
926 }
927
928 TRange<T> operator+(float value)
929 {
930 TRange<T> trReturn(this);
931 trReturn += value;
932 return trReturn;
933 }
934
935 TRange<T> operator+(double value)
936 {
937 TRange<T> trReturn(this);
938 trReturn += value;
939 return trReturn;
940 }
941
942 TRange<T> operator+(const TRange<int32_t>& tr)
943 {
944 TRange<T> trReturn(this);
945 trReturn += tr;
946 return trReturn;
947 }
948
949 TRange<T> operator+(const TRange<int64_t>& tr)
950 {
951 TRange<T> trReturn(this);
952 trReturn += tr;
953 return trReturn;
954 }
955
956 TRange<T> operator+(const TRange<float>& tr)
957 {
958 TRange<T> trReturn(this);
959 trReturn += tr;
960 return trReturn;
961 }
962
963 TRange<T> operator+(const TRange<double>& tr)
964 {
965 TRange<T> trReturn(this);
966 trReturn += tr;
967 return trReturn;
968 }
969
970 TRange<T> operator-(int32_t value)
971 {
972 TRange<T> trReturn(this);
973 trReturn -= value;
974 return trReturn;
975 }
976
977 TRange<T> operator-(int64_t value)
978 {
979 TRange<T> trReturn(this);
980 trReturn -= value;
981 return trReturn;
982 }
983
984 TRange<T> operator-(float value)
985 {
986 TRange<T> trReturn(this);
987 trReturn -= value;
988 return trReturn;
989 }
990
991 TRange<T> operator-(double value)
992 {
993 TRange<T> trReturn(this);
994 trReturn -= value;
995 return trReturn;
996 }
997
998 TRange<T> operator-(const TRange<int32_t>& tr)
999 {
1000 TRange<T> trReturn(this);
1001 trReturn -= tr;
1002 return trReturn;
1003 }
1004
1005 TRange<T> operator-(const TRange<int64_t>& tr)
1006 {
1007 TRange<T> trReturn(this);
1008 trReturn -= tr;
1009 return trReturn;
1010 }
1011
1012 TRange<T> operator-(const TRange<float>& tr)
1013 {
1014 TRange<T> trReturn(this);
1015 trReturn -= tr;
1016 return trReturn;
1017 }
1018
1019 TRange<T> operator-(const TRange<double>& tr)
1020 {
1021 TRange<T> trReturn(this);
1022 trReturn -= tr;
1023 return trReturn;
1024 }
1025
1026 TRange<T> operator*(int32_t value)
1027 {
1028 TRange<T> trReturn(this);
1029 trReturn *= value;
1030 return trReturn;
1031 }
1032
1033 TRange<T> operator*(int64_t value)
1034 {
1035 TRange<T> trReturn(this);
1036 trReturn *= value;
1037 return trReturn;
1038 }
1039
1040 TRange<T> operator*(float value)
1041 {
1042 TRange<T> trReturn(this);
1043 trReturn *= value;
1044 return trReturn;
1045 }
1046
1047 TRange<T> operator*(double value)
1048 {
1049 TRange<T> trReturn(this);
1050 trReturn *= value;
1051 return trReturn;
1052 }
1053
1054 TRange<T> operator*(const TRange<int32_t>& tr)
1055 {
1056 TRange<T> trReturn(this);
1057 trReturn *= tr;
1058 return trReturn;
1059 }
1060
1061 TRange<T> operator*(const TRange<int64_t>& tr)
1062 {
1063 TRange<T> trReturn(this);
1064 trReturn *= tr;
1065 return trReturn;
1066 }
1067
1068 TRange<T> operator*(const TRange<float>& tr)
1069 {
1070 TRange<T> trReturn(this);
1071 trReturn *= tr;
1072 return trReturn;
1073 }
1074
1075 TRange<T> operator*(const TRange<double>& tr)
1076 {
1077 TRange<T> trReturn(this);
1078 trReturn *= tr;
1079 return trReturn;
1080 }
1081
1082 TRange<T> operator/(int32_t value)
1083 {
1084 TRange<T> trReturn(this);
1085 trReturn /= value;
1086 return trReturn;
1087 }
1088
1089 TRange<T> operator/(int64_t value)
1090 {
1091 TRange<T> trReturn(this);
1092 trReturn /= value;
1093 return trReturn;
1094 }
1095
1096 TRange<T> operator/(float value)
1097 {
1098 TRange<T> trReturn(this);
1099 trReturn /= value;
1100 return trReturn;
1101 }
1102
1103 TRange<T> operator/(double value)
1104 {
1105 TRange<T> trReturn(this);
1106 trReturn /= value;
1107 return trReturn;
1108 }
1109
1110 TRange<T> operator/(const TRange<int32_t>& tr)
1111 {
1112 TRange<T> trReturn(this);
1113 trReturn /= tr;
1114 return trReturn;
1115 }
1116
1117 TRange<T> operator/(const TRange<int64_t>& tr)
1118 {
1119 TRange<T> trReturn(this);
1120 trReturn /= tr;
1121 return trReturn;
1122 }
1123
1124 TRange<T> operator/(const TRange<float>& tr)
1125 {
1126 TRange<T> trReturn(this);
1127 trReturn /= tr;
1128 return trReturn;
1129 }
1130
1131 TRange<T> operator/(const TRange<double>& tr)
1132 {
1133 TRange<T> trReturn(this);
1134 trReturn /= tr;
1135 return trReturn;
1136 }
1137
1138 friend TRange<T> operator+(int32_t value, const TRange<T>& tr)
1139 {
1140 return TRange<T>(TRange<double>(tr) + value);
1141 }
1142 friend TRange<T> operator+(int64_t value, const TRange<T>& tr)
1143 {
1144 return TRange<T>(TRange<double>(tr) + value);
1145 }
1146 friend TRange<T> operator+(float value, const TRange<T>& tr)
1147 {
1148 return TRange<T>(TRange<double>(tr) + value);
1149 }
1150 friend TRange<T> operator+(double value, const TRange<T>& tr)
1151 {
1152 return TRange<T>(TRange<double>(tr) + value);
1153 }
1154
1155 friend TRange<T> operator-(int32_t value, const TRange<T>& tr)
1156 {
1157 return TRange<T>(TPoint<T>((T)(value - tr.tpPoints[0].x), (T)(value - tr.tpPoints[0].y)), TPoint<T>((T)(value - tr.tpPoints[1].x), (T)(value - tr.tpPoints[1].y)));
1158 }
1159 friend TRange<T> operator-(int64_t value, const TRange<T>& tr)
1160 {
1161 return TRange<T>(TPoint<T>((T)(value - tr.tpPoints[0].x), (T)(value - tr.tpPoints[0].y)), TPoint<T>((T)(value - tr.tpPoints[1].x), (T)(value - tr.tpPoints[1].y)));
1162 }
1163 friend TRange<T> operator-(float value, const TRange<T>& tr)
1164 {
1165 return TRange<T>(TPoint<T>((T)(value - tr.tpPoints[0].x), (T)(value - tr.tpPoints[0].y)), TPoint<T>((T)(value - tr.tpPoints[1].x), (T)(value - tr.tpPoints[1].y)));
1166 }
1167 friend TRange<T> operator-(double value, const TRange<T>& tr)
1168 {
1169 return TRange<T>(TPoint<T>((T)(value - tr.tpPoints[0].x), (T)(value - tr.tpPoints[0].y)), TPoint<T>((T)(value - tr.tpPoints[1].x), (T)(value - tr.tpPoints[1].y)));
1170 }
1171
1172 friend TRange<T> operator*(int32_t value, const TRange<T>& tr)
1173 {
1174 return TRange<T>(TRange<double>(tr) * value);
1175 }
1176 friend TRange<T> operator*(int64_t value, const TRange<T>& tr)
1177 {
1178 return TRange<T>(TRange<double>(tr) * value);
1179 }
1180 friend TRange<T> operator*(float value, const TRange<T>& tr)
1181 {
1182 return TRange<T>(TRange<double>(tr) * value);
1183 }
1184 friend TRange<T> operator*(double value, const TRange<T>& tr)
1185 {
1186 return TRange<T>(TRange<double>(tr) * value);
1187 }
1188
1189 friend TRange<T> operator/(int32_t value, const TRange<T>& tr)
1190 {
1191 return TRange<T>(TPoint<T>((T)(value / tr.tpPoints[0].x), (T)(value / tr.tpPoints[0].y)), TPoint<T>((T)(value / tr.tpPoints[1].x), (T)(value / tr.tpPoints[1].y)));
1192 }
1193 friend TRange<T> operator/(int64_t value, const TRange<T>& tr)
1194 {
1195 return TRange<T>(TPoint<T>((T)(value / tr.tpPoints[0].x), (T)(value / tr.tpPoints[0].y)), TPoint<T>((T)(value / tr.tpPoints[1].x), (T)(value / tr.tpPoints[1].y)));
1196 }
1197 friend TRange<T> operator/(float value, const TRange<T>& tr)
1198 {
1199 return TRange<T>(TPoint<T>((T)(value / tr.tpPoints[0].x), (T)(value / tr.tpPoints[0].y)), TPoint<T>((T)(value / tr.tpPoints[1].x), (T)(value / tr.tpPoints[1].y)));
1200 }
1201 friend TRange<T> operator/(double value, const TRange<T>& tr)
1202 {
1203 return TRange<T>(TPoint<T>((T)(value / tr.tpPoints[0].x), (T)(value / tr.tpPoints[0].y)), TPoint<T>((T)(value / tr.tpPoints[1].x), (T)(value / tr.tpPoints[1].y)));
1204 }
1205 };
1206 #pragma pack(pop)
1207
1208 typedef TRange<int16_t> TRangeS;
1209 typedef TRange<uint16_t> TRangeUS;
1210 typedef TRange<int32_t> TRangeL;
1211 typedef TRange<uint32_t> TRangeUL;
1212 typedef TRange<int64_t> TRangeLL;
1213 typedef TRange<uint64_t> TRangeULL;
1214 typedef TRange<float> TRangeF;
1215 typedef TRange<double> TRangeD;
1216 }
1217}
FLImaging::Base::TPoint
Simplified class representing a point.
Definition TPoint.h:37
FLImaging::Base::TRange
Simplified class representing a 2D range.
Definition TRange.h:35
FLImaging::Base::TRect
Simplified class representing a rectangle.
Definition TRect.h:37
Generated on Thu May 8 2025 22:19:31 for FLImaging by doxygen 1.12.0