FLImaging 7.6.11.1
TRange.h
1#pragma once
2
10
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:
44 TPoint<T> tpPoints[2];
45
53 TRange()
54 {
55 }
56
72 TRange(T tLBX, T tLBY, T tUBX, T tUBY)
73 {
74 tpPoints[0].x = tLBX;
75 tpPoints[0].y = tLBY;
76 tpPoints[1].x = tUBX;
77 tpPoints[1].y = tUBY;
78 }
79
89 TRange(const TRect<T>& tr)
90 {
91 tpPoints[0].x = tr.left;
92 tpPoints[0].y = tr.top;
93 tpPoints[1].x = tr.right;
94 tpPoints[1].y = tr.bottom;
95 }
96
106 TRange(const TRange<int16_t>& tr)
107 {
108 tpPoints[0].Set(tr.tpPoints[0]);
109 tpPoints[1].Set(tr.tpPoints[1]);
110 }
111
121 TRange(const TRange<int16_t>* pTr)
122 {
123 if(pTr)
124 {
125 tpPoints[0].Set(pTr->tpPoints[0]);
126 tpPoints[1].Set(pTr->tpPoints[1]);
127 }
128 }
129
139 TRange(const TRange<uint16_t>& tr)
140 {
141 tpPoints[0].Set(tr.tpPoints[0]);
142 tpPoints[1].Set(tr.tpPoints[1]);
143 }
144
154 TRange(const TRange<uint16_t>* pTr)
155 {
156 if(pTr)
157 {
158 tpPoints[0].Set(pTr->tpPoints[0]);
159 tpPoints[1].Set(pTr->tpPoints[1]);
160 }
161 }
162
172 TRange(const TRange<int32_t>& tr)
173 {
174 tpPoints[0].Set(tr.tpPoints[0]);
175 tpPoints[1].Set(tr.tpPoints[1]);
176 }
177
187 TRange(const TRange<int32_t>* pTr)
188 {
189 if(pTr)
190 {
191 tpPoints[0].Set(pTr->tpPoints[0]);
192 tpPoints[1].Set(pTr->tpPoints[1]);
193 }
194 }
195
205 TRange(const TRange<uint32_t>& tr)
206 {
207 tpPoints[0].Set(tr.tpPoints[0]);
208 tpPoints[1].Set(tr.tpPoints[1]);
209 }
210
220 TRange(const TRange<uint32_t>* pTr)
221 {
222 if(pTr)
223 {
224 tpPoints[0].Set(pTr->tpPoints[0]);
225 tpPoints[1].Set(pTr->tpPoints[1]);
226 }
227 }
228
238 TRange(const TRange<int64_t>& tr)
239 {
240 tpPoints[0].Set(tr.tpPoints[0]);
241 tpPoints[1].Set(tr.tpPoints[1]);
242 }
243
253 TRange(const TRange<int64_t>* pTr)
254 {
255 if(pTr)
256 {
257 tpPoints[0].Set(pTr->tpPoints[0]);
258 tpPoints[1].Set(pTr->tpPoints[1]);
259 }
260 }
261
271 TRange(const TRange<uint64_t>& tr)
272 {
273 tpPoints[0].Set(tr.tpPoints[0]);
274 tpPoints[1].Set(tr.tpPoints[1]);
275 }
276
286 TRange(const TRange<uint64_t>* pTr)
287 {
288 if(pTr)
289 {
290 tpPoints[0].Set(pTr->tpPoints[0]);
291 tpPoints[1].Set(pTr->tpPoints[1]);
292 }
293 }
294
304 TRange(const TRange<float>& tr)
305 {
306 tpPoints[0].Set(tr.tpPoints[0]);
307 tpPoints[1].Set(tr.tpPoints[1]);
308 }
309
319 TRange(const TRange<float>* pTr)
320 {
321 if(pTr)
322 {
323 tpPoints[0].Set(pTr->tpPoints[0]);
324 tpPoints[1].Set(pTr->tpPoints[1]);
325 }
326 }
327
337 TRange(const TRange<double>& tr)
338 {
339 tpPoints[0].Set(tr.tpPoints[0]);
340 tpPoints[1].Set(tr.tpPoints[1]);
341 }
342
352 TRange(const TRange<double>* pTr)
353 {
354 if(pTr)
355 {
356 tpPoints[0].Set(pTr->tpPoints[0]);
357 tpPoints[1].Set(pTr->tpPoints[1]);
358 }
359 }
360
372 TRange(const TPoint<int16_t>& tpLB, const TPoint<int16_t>& tpUB)
373 {
374 tpPoints[0].Set(tpLB);
375 tpPoints[1].Set(tpUB);
376 }
377
389 TRange(const TPoint<int16_t>* pTpLB, const TPoint<int16_t>* pTpUB)
390 {
391 if(pTpLB && pTpUB)
392 {
393 tpPoints[0].Set(pTpLB);
394 tpPoints[1].Set(pTpUB);
395 }
396 }
397
409 TRange(const TPoint<uint16_t>& tpLB, const TPoint<uint16_t>& tpUB)
410 {
411 tpPoints[0].Set(tpLB);
412 tpPoints[1].Set(tpUB);
413 }
414
426 TRange(const TPoint<uint16_t>* pTpLB, const TPoint<uint16_t>* pTpUB)
427 {
428 if(pTpLB && pTpUB)
429 {
430 tpPoints[0].Set(pTpLB);
431 tpPoints[1].Set(pTpUB);
432 }
433 }
434
446 TRange(const TPoint<int32_t>& tpLB, const TPoint<int32_t>& tpUB)
447 {
448 tpPoints[0].Set(tpLB);
449 tpPoints[1].Set(tpUB);
450 }
451
463 TRange(const TPoint<int32_t>* pTpLB, const TPoint<int32_t>* pTpUB)
464 {
465 if(pTpLB && pTpUB)
466 {
467 tpPoints[0].Set(pTpLB);
468 tpPoints[1].Set(pTpUB);
469 }
470 }
471
483 TRange(const TPoint<uint32_t>& tpLB, const TPoint<uint32_t>& tpUB)
484 {
485 tpPoints[0].Set(tpLB);
486 tpPoints[1].Set(tpUB);
487 }
488
500 TRange(const TPoint<uint32_t>* pTpLB, const TPoint<uint32_t>* pTpUB)
501 {
502 if(pTpLB && pTpUB)
503 {
504 tpPoints[0].Set(pTpLB);
505 tpPoints[1].Set(pTpUB);
506 }
507 }
508
520 TRange(const TPoint<int64_t>& tpLB, const TPoint<int64_t>& tpUB)
521 {
522 tpPoints[0].Set(tpLB);
523 tpPoints[1].Set(tpUB);
524 }
525
537 TRange(const TPoint<int64_t>* pTpLB, const TPoint<int64_t>* pTpUB)
538 {
539 if(pTpLB && pTpUB)
540 {
541 tpPoints[0].Set(pTpLB);
542 tpPoints[1].Set(pTpUB);
543 }
544 }
545
557 TRange(const TPoint<uint64_t>& tpLB, const TPoint<uint64_t>& tpUB)
558 {
559 tpPoints[0].Set(tpLB);
560 tpPoints[1].Set(tpUB);
561 }
562
574 TRange(const TPoint<uint64_t>* pTpLB, const TPoint<uint64_t>* pTpUB)
575 {
576 if(pTpLB && pTpUB)
577 {
578 tpPoints[0].Set(pTpLB);
579 tpPoints[1].Set(pTpUB);
580 }
581 }
582
594 TRange(const TPoint<float>& tpLB, const TPoint<float>& tpUB)
595 {
596 tpPoints[0].Set(tpLB);
597 tpPoints[1].Set(tpUB);
598 }
599
611 TRange(const TPoint<float>* pTpLB, const TPoint<float>* pTpUB)
612 {
613 if(pTpLB && pTpUB)
614 {
615 tpPoints[0].Set(pTpLB);
616 tpPoints[1].Set(pTpUB);
617 }
618 }
619
631 TRange(const TPoint<double>& tpLB, const TPoint<double>& tpUB)
632 {
633 tpPoints[0].Set(tpLB);
634 tpPoints[1].Set(tpUB);
635 }
636
648 TRange(const TPoint<double>* pTpLB, const TPoint<double>* pTpUB)
649 {
650 if(pTpLB && pTpUB)
651 {
652 tpPoints[0].Set(pTpLB);
653 tpPoints[1].Set(pTpUB);
654 }
655 }
656
657
673 void Set(T tLBX, T tLBY, T tUBX, T tUBY)
674 {
675 tpPoints[0].x = tLBX;
676 tpPoints[0].y = tLBY;
677 tpPoints[1].x = tUBX;
678 tpPoints[1].y = tUBY;
679 }
680
690 void Set(const TRect<T>& tr)
691 {
692 tpPoints[0].x = tr.left;
693 tpPoints[0].y = tr.top;
694 tpPoints[1].x = tr.right;
695 tpPoints[1].y = tr.bottom;
696 }
697
707 void Set(const TRange<int16_t>& tr)
708 {
709 tpPoints[0].Set(tr.tpPoints[0]);
710 tpPoints[1].Set(tr.tpPoints[1]);
711 }
712
722 void Set(const TRange<int16_t>* pTr)
723 {
724 if(pTr)
725 {
726 tpPoints[0].Set(pTr->tpPoints[0]);
727 tpPoints[1].Set(pTr->tpPoints[1]);
728 }
729 }
730
740 void Set(const TRange<uint16_t>& tr)
741 {
742 tpPoints[0].Set(tr.tpPoints[0]);
743 tpPoints[1].Set(tr.tpPoints[1]);
744 }
745
755 void Set(const TRange<uint16_t>* pTr)
756 {
757 if(pTr)
758 {
759 tpPoints[0].Set(pTr->tpPoints[0]);
760 tpPoints[1].Set(pTr->tpPoints[1]);
761 }
762 }
763
773 void Set(const TRange<int32_t>& tr)
774 {
775 tpPoints[0].Set(tr.tpPoints[0]);
776 tpPoints[1].Set(tr.tpPoints[1]);
777 }
778
788 void Set(const TRange<int32_t>* pTr)
789 {
790 if(pTr)
791 {
792 tpPoints[0].Set(pTr->tpPoints[0]);
793 tpPoints[1].Set(pTr->tpPoints[1]);
794 }
795 }
796
806 void Set(const TRange<uint32_t>& tr)
807 {
808 tpPoints[0].Set(tr.tpPoints[0]);
809 tpPoints[1].Set(tr.tpPoints[1]);
810 }
811
821 void Set(const TRange<uint32_t>* pTr)
822 {
823 if(pTr)
824 {
825 tpPoints[0].Set(pTr->tpPoints[0]);
826 tpPoints[1].Set(pTr->tpPoints[1]);
827 }
828 }
829
839 void Set(const TRange<int64_t>& tr)
840 {
841 tpPoints[0].Set(tr.tpPoints[0]);
842 tpPoints[1].Set(tr.tpPoints[1]);
843 }
844
854 void Set(const TRange<int64_t>* pTr)
855 {
856 if(pTr)
857 {
858 tpPoints[0].Set(pTr->tpPoints[0]);
859 tpPoints[1].Set(pTr->tpPoints[1]);
860 }
861 }
862
872 void Set(const TRange<uint64_t>& tr)
873 {
874 tpPoints[0].Set(tr.tpPoints[0]);
875 tpPoints[1].Set(tr.tpPoints[1]);
876 }
877
887 void Set(const TRange<uint64_t>* pTr)
888 {
889 if(pTr)
890 {
891 tpPoints[0].Set(pTr->tpPoints[0]);
892 tpPoints[1].Set(pTr->tpPoints[1]);
893 }
894 }
895
905 void Set(const TRange<float>& tr)
906 {
907 tpPoints[0].Set(tr.tpPoints[0]);
908 tpPoints[1].Set(tr.tpPoints[1]);
909 }
910
920 void Set(const TRange<float>* pTr)
921 {
922 if(pTr)
923 {
924 tpPoints[0].Set(pTr->tpPoints[0]);
925 tpPoints[1].Set(pTr->tpPoints[1]);
926 }
927 }
928
938 void Set(const TRange<double>& tr)
939 {
940 tpPoints[0].Set(tr.tpPoints[0]);
941 tpPoints[1].Set(tr.tpPoints[1]);
942 }
943
953 void Set(const TRange<double>* pTr)
954 {
955 if(pTr)
956 {
957 tpPoints[0].Set(pTr->tpPoints[0]);
958 tpPoints[1].Set(pTr->tpPoints[1]);
959 }
960 }
961
973 void Set(const TPoint<int16_t>& tpLB, const TPoint<int16_t>& tpUB)
974 {
975 tpPoints[0].Set(tpLB);
976 tpPoints[1].Set(tpUB);
977 }
978
990 void Set(const TPoint<int16_t>* pTpLB, const TPoint<int16_t>* pTpUB)
991 {
992 if(pTpLB && pTpUB)
993 {
994 tpPoints[0].Set(pTpLB);
995 tpPoints[1].Set(pTpUB);
996 }
997 }
998
1010 void Set(const TPoint<uint16_t>& tpLB, const TPoint<uint16_t>& tpUB)
1011 {
1012 tpPoints[0].Set(tpLB);
1013 tpPoints[1].Set(tpUB);
1014 }
1015
1027 void Set(const TPoint<uint16_t>* pTpLB, const TPoint<uint16_t>* pTpUB)
1028 {
1029 if(pTpLB && pTpUB)
1030 {
1031 tpPoints[0].Set(pTpLB);
1032 tpPoints[1].Set(pTpUB);
1033 }
1034 }
1035
1047 void Set(const TPoint<int32_t>& tpLB, const TPoint<int32_t>& tpUB)
1048 {
1049 tpPoints[0].Set(tpLB);
1050 tpPoints[1].Set(tpUB);
1051 }
1052
1064 void Set(const TPoint<int32_t>* pTpLB, const TPoint<int32_t>* pTpUB)
1065 {
1066 if(pTpLB && pTpUB)
1067 {
1068 tpPoints[0].Set(pTpLB);
1069 tpPoints[1].Set(pTpUB);
1070 }
1071 }
1072
1084 void Set(const TPoint<uint32_t>& tpLB, const TPoint<uint32_t>& tpUB)
1085 {
1086 tpPoints[0].Set(tpLB);
1087 tpPoints[1].Set(tpUB);
1088 }
1089
1101 void Set(const TPoint<uint32_t>* pTpLB, const TPoint<uint32_t>* pTpUB)
1102 {
1103 if(pTpLB && pTpUB)
1104 {
1105 tpPoints[0].Set(pTpLB);
1106 tpPoints[1].Set(pTpUB);
1107 }
1108 }
1109
1121 void Set(const TPoint<int64_t>& tpLB, const TPoint<int64_t>& tpUB)
1122 {
1123 tpPoints[0].Set(tpLB);
1124 tpPoints[1].Set(tpUB);
1125 }
1126
1138 void Set(const TPoint<int64_t>* pTpLB, const TPoint<int64_t>* pTpUB)
1139 {
1140 if(pTpLB && pTpUB)
1141 {
1142 tpPoints[0].Set(pTpLB);
1143 tpPoints[1].Set(pTpUB);
1144 }
1145 }
1146
1158 void Set(const TPoint<uint64_t>& tpLB, const TPoint<uint64_t>& tpUB)
1159 {
1160 tpPoints[0].Set(tpLB);
1161 tpPoints[1].Set(tpUB);
1162 }
1163
1175 void Set(const TPoint<uint64_t>* pTpLB, const TPoint<uint64_t>* pTpUB)
1176 {
1177 if(pTpLB && pTpUB)
1178 {
1179 tpPoints[0].Set(pTpLB);
1180 tpPoints[1].Set(pTpUB);
1181 }
1182 }
1183
1195 void Set(const TPoint<float>& tpLB, const TPoint<float>& tpUB)
1196 {
1197 tpPoints[0].Set(tpLB);
1198 tpPoints[1].Set(tpUB);
1199 }
1200
1212 void Set(const TPoint<float>* pTpLB, const TPoint<float>* pTpUB)
1213 {
1214 if(pTpLB && pTpUB)
1215 {
1216 tpPoints[0].Set(pTpLB);
1217 tpPoints[1].Set(pTpUB);
1218 }
1219 }
1220
1232 void Set(const TPoint<double>& tpLB, const TPoint<double>& tpUB)
1233 {
1234 tpPoints[0].Set(tpLB);
1235 tpPoints[1].Set(tpUB);
1236 }
1237
1249 void Set(const TPoint<double>* pTpLB, const TPoint<double>* pTpUB)
1250 {
1251 if(pTpLB && pTpUB)
1252 {
1253 tpPoints[0].Set(pTpLB);
1254 tpPoints[1].Set(pTpUB);
1255 }
1256 }
1257
1258
1270 const TRange<T>& operator=(int32_t value)
1271 {
1272 tpPoints[0] = value;
1273 tpPoints[1] = value;
1274
1275 return *this;
1276 }
1277
1289 const TRange<T>& operator=(int64_t value)
1290 {
1291 tpPoints[0] = value;
1292 tpPoints[1] = value;
1293
1294 return *this;
1295 }
1296
1308 const TRange<T>& operator=(float value)
1309 {
1310 tpPoints[0] = value;
1311 tpPoints[1] = value;
1312
1313 return *this;
1314 }
1315
1327 const TRange<T>& operator=(double value)
1328 {
1329 tpPoints[0] = value;
1330 tpPoints[1] = value;
1331
1332 return *this;
1333 }
1334
1346 const TRange<T>& operator=(const TRange<int32_t>& tr)
1347 {
1348 Set(tr);
1349
1350 return *this;
1351 }
1352
1364 const TRange<T>& operator=(const TRange<int64_t>& tr)
1365 {
1366 Set(tr);
1367
1368 return *this;
1369 }
1370
1382 const TRange<T>& operator=(const TRange<float>& tr)
1383 {
1384 Set(tr);
1385
1386 return *this;
1387 }
1388
1400 const TRange<T>& operator=(const TRange<double>& tr)
1401 {
1402 Set(tr);
1403
1404 return *this;
1405 }
1406
1418 bool operator==(const TRange<int32_t>& tr)
1419 {
1420 return tpPoints[0] == tr.tpPoints[0] && tpPoints[1] == tr.tpPoints[1];
1421 }
1422
1434 bool operator==(const TRange<int64_t>& tr)
1435 {
1436 return tpPoints[0] == tr.tpPoints[0] && tpPoints[1] == tr.tpPoints[1];
1437 }
1438
1450 bool operator==(const TRange<float>& tr)
1451 {
1452 return tpPoints[0] == tr.tpPoints[0] && tpPoints[1] == tr.tpPoints[1];
1453 }
1454
1466 bool operator==(const TRange<double>& tr)
1467 {
1468 return tpPoints[0] == tr.tpPoints[0] && tpPoints[1] == tr.tpPoints[1];
1469 }
1470
1482 bool operator!=(const TRange<int32_t>& tr)
1483 {
1484 return tpPoints[0] != tr.tpPoints[0] || tpPoints[1] != tr.tpPoints[1];
1485 }
1486
1498 bool operator!=(const TRange<int64_t>& tr)
1499 {
1500 return tpPoints[0] != tr.tpPoints[0] || tpPoints[1] != tr.tpPoints[1];
1501 }
1502
1514 bool operator!=(const TRange<float>& tr)
1515 {
1516 return tpPoints[0] != tr.tpPoints[0] || tpPoints[1] != tr.tpPoints[1];
1517 }
1518
1530 bool operator!=(const TRange<double>& tr)
1531 {
1532 return tpPoints[0] != tr.tpPoints[0] || tpPoints[1] != tr.tpPoints[1];
1533 }
1534
1546 const TRange<T>& operator+=(int32_t value)
1547 {
1548 tpPoints[0] += value;
1549 tpPoints[1] += value;
1550
1551 return *this;
1552 }
1553
1565 const TRange<T>& operator+=(int64_t value)
1566 {
1567 tpPoints[0] += value;
1568 tpPoints[1] += value;
1569
1570 return *this;
1571 }
1572
1584 const TRange<T>& operator+=(float value)
1585 {
1586 tpPoints[0] += value;
1587 tpPoints[1] += value;
1588
1589 return *this;
1590 }
1591
1603 const TRange<T>& operator+=(double value)
1604 {
1605 tpPoints[0] += value;
1606 tpPoints[1] += value;
1607
1608 return *this;
1609 }
1610
1622 const TRange<T>& operator+=(const TRange<int32_t>& tr)
1623 {
1624 tpPoints[0] += tr.tpPoints[0];
1625 tpPoints[1] += tr.tpPoints[1];
1626
1627 return *this;
1628 }
1629
1641 const TRange<T>& operator+=(const TRange<int64_t>& tr)
1642 {
1643 tpPoints[0] += tr.tpPoints[0];
1644 tpPoints[1] += tr.tpPoints[1];
1645
1646 return *this;
1647 }
1648
1660 const TRange<T>& operator+=(const TRange<float>& tr)
1661 {
1662 tpPoints[0] += tr.tpPoints[0];
1663 tpPoints[1] += tr.tpPoints[1];
1664
1665 return *this;
1666 }
1667
1679 const TRange<T>& operator+=(const TRange<double>& tr)
1680 {
1681 tpPoints[0] += tr.tpPoints[0];
1682 tpPoints[1] += tr.tpPoints[1];
1683
1684 return *this;
1685 }
1686
1698 const TRange<T>& operator-=(int32_t value)
1699 {
1700 tpPoints[0] -= value;
1701 tpPoints[1] -= value;
1702
1703 return *this;
1704 }
1705
1717 const TRange<T>& operator-=(int64_t value)
1718 {
1719 tpPoints[0] -= value;
1720 tpPoints[1] -= value;
1721
1722 return *this;
1723 }
1724
1736 const TRange<T>& operator-=(float value)
1737 {
1738 tpPoints[0] -= value;
1739 tpPoints[1] -= value;
1740
1741 return *this;
1742 }
1743
1755 const TRange<T>& operator-=(double value)
1756 {
1757 tpPoints[0] -= value;
1758 tpPoints[1] -= value;
1759
1760 return *this;
1761 }
1762
1774 const TRange<T>& operator-=(const TRange<int32_t>& tr)
1775 {
1776 tpPoints[0] -= tr.tpPoints[0];
1777 tpPoints[1] -= tr.tpPoints[1];
1778
1779 return *this;
1780 }
1781
1793 const TRange<T>& operator-=(const TRange<int64_t>& tr)
1794 {
1795 tpPoints[0] -= tr.tpPoints[0];
1796 tpPoints[1] -= tr.tpPoints[1];
1797
1798 return *this;
1799 }
1800
1812 const TRange<T>& operator-=(const TRange<float>& tr)
1813 {
1814 tpPoints[0] -= tr.tpPoints[0];
1815 tpPoints[1] -= tr.tpPoints[1];
1816
1817 return *this;
1818 }
1819
1831 const TRange<T>& operator-=(const TRange<double>& tr)
1832 {
1833 tpPoints[0] -= tr.tpPoints[0];
1834 tpPoints[1] -= tr.tpPoints[1];
1835
1836 return *this;
1837 }
1838
1850 const TRange<T>& operator*=(int32_t value)
1851 {
1852 tpPoints[0] *= value;
1853 tpPoints[1] *= value;
1854
1855 return *this;
1856 }
1857
1869 const TRange<T>& operator*=(int64_t value)
1870 {
1871 tpPoints[0] *= value;
1872 tpPoints[1] *= value;
1873
1874 return *this;
1875 }
1876
1888 const TRange<T>& operator*=(float value)
1889 {
1890 tpPoints[0] *= value;
1891 tpPoints[1] *= value;
1892
1893 return *this;
1894 }
1895
1907 const TRange<T>& operator*=(double value)
1908 {
1909 tpPoints[0] *= value;
1910 tpPoints[1] *= value;
1911
1912 return *this;
1913 }
1914
1926 const TRange<T>& operator*=(const TRange<int32_t>& tr)
1927 {
1928 tpPoints[0] *= tr.tpPoints[0];
1929 tpPoints[1] *= tr.tpPoints[1];
1930
1931 return *this;
1932 }
1933
1945 const TRange<T>& operator*=(const TRange<int64_t>& tr)
1946 {
1947 tpPoints[0] *= tr.tpPoints[0];
1948 tpPoints[1] *= tr.tpPoints[1];
1949
1950 return *this;
1951 }
1952
1964 const TRange<T>& operator*=(const TRange<float>& tr)
1965 {
1966 tpPoints[0] *= tr.tpPoints[0];
1967 tpPoints[1] *= tr.tpPoints[1];
1968
1969 return *this;
1970 }
1971
1983 const TRange<T>& operator*=(const TRange<double>& tr)
1984 {
1985 tpPoints[0] *= tr.tpPoints[0];
1986 tpPoints[1] *= tr.tpPoints[1];
1987
1988 return *this;
1989 }
1990
2002 const TRange<T>& operator/=(int32_t value)
2003 {
2004 tpPoints[0] /= value;
2005 tpPoints[1] /= value;
2006
2007 return *this;
2008 }
2009
2021 const TRange<T>& operator/=(int64_t value)
2022 {
2023 tpPoints[0] /= value;
2024 tpPoints[1] /= value;
2025
2026 return *this;
2027 }
2028
2040 const TRange<T>& operator/=(float value)
2041 {
2042 tpPoints[0] /= value;
2043 tpPoints[1] /= value;
2044
2045 return *this;
2046 }
2047
2059 const TRange<T>& operator/=(double value)
2060 {
2061 tpPoints[0] /= value;
2062 tpPoints[1] /= value;
2063
2064 return *this;
2065 }
2066
2078 const TRange<T>& operator/=(const TRange<int32_t>& tr)
2079 {
2080 tpPoints[0] /= tr.tpPoints[0];
2081 tpPoints[1] /= tr.tpPoints[1];
2082
2083 return *this;
2084 }
2085
2097 const TRange<T>& operator/=(const TRange<int64_t>& tr)
2098 {
2099 tpPoints[0] /= tr.tpPoints[0];
2100 tpPoints[1] /= tr.tpPoints[1];
2101
2102 return *this;
2103 }
2104
2116 const TRange<T>& operator/=(const TRange<float>& tr)
2117 {
2118 tpPoints[0] /= tr.tpPoints[0];
2119 tpPoints[1] /= tr.tpPoints[1];
2120
2121 return *this;
2122 }
2123
2135 const TRange<T>& operator/=(const TRange<double>& tr)
2136 {
2137 tpPoints[0] /= tr.tpPoints[0];
2138 tpPoints[1] /= tr.tpPoints[1];
2139
2140 return *this;
2141 }
2142
2154 TRange<T> operator+(int32_t value)
2155 {
2156 TRange<T> trReturn(this);
2157 trReturn += value;
2158 return trReturn;
2159 }
2160
2172 TRange<T> operator+(int64_t value)
2173 {
2174 TRange<T> trReturn(this);
2175 trReturn += value;
2176 return trReturn;
2177 }
2178
2190 TRange<T> operator+(float value)
2191 {
2192 TRange<T> trReturn(this);
2193 trReturn += value;
2194 return trReturn;
2195 }
2196
2208 TRange<T> operator+(double value)
2209 {
2210 TRange<T> trReturn(this);
2211 trReturn += value;
2212 return trReturn;
2213 }
2214
2226 TRange<T> operator+(const TRange<int32_t>& tr)
2227 {
2228 TRange<T> trReturn(this);
2229 trReturn += tr;
2230 return trReturn;
2231 }
2232
2244 TRange<T> operator+(const TRange<int64_t>& tr)
2245 {
2246 TRange<T> trReturn(this);
2247 trReturn += tr;
2248 return trReturn;
2249 }
2250
2262 TRange<T> operator+(const TRange<float>& tr)
2263 {
2264 TRange<T> trReturn(this);
2265 trReturn += tr;
2266 return trReturn;
2267 }
2268
2280 TRange<T> operator+(const TRange<double>& tr)
2281 {
2282 TRange<T> trReturn(this);
2283 trReturn += tr;
2284 return trReturn;
2285 }
2286
2298 TRange<T> operator-(int32_t value)
2299 {
2300 TRange<T> trReturn(this);
2301 trReturn -= value;
2302 return trReturn;
2303 }
2304
2316 TRange<T> operator-(int64_t value)
2317 {
2318 TRange<T> trReturn(this);
2319 trReturn -= value;
2320 return trReturn;
2321 }
2322
2334 TRange<T> operator-(float value)
2335 {
2336 TRange<T> trReturn(this);
2337 trReturn -= value;
2338 return trReturn;
2339 }
2340
2352 TRange<T> operator-(double value)
2353 {
2354 TRange<T> trReturn(this);
2355 trReturn -= value;
2356 return trReturn;
2357 }
2358
2370 TRange<T> operator-(const TRange<int32_t>& tr)
2371 {
2372 TRange<T> trReturn(this);
2373 trReturn -= tr;
2374 return trReturn;
2375 }
2376
2388 TRange<T> operator-(const TRange<int64_t>& tr)
2389 {
2390 TRange<T> trReturn(this);
2391 trReturn -= tr;
2392 return trReturn;
2393 }
2394
2406 TRange<T> operator-(const TRange<float>& tr)
2407 {
2408 TRange<T> trReturn(this);
2409 trReturn -= tr;
2410 return trReturn;
2411 }
2412
2424 TRange<T> operator-(const TRange<double>& tr)
2425 {
2426 TRange<T> trReturn(this);
2427 trReturn -= tr;
2428 return trReturn;
2429 }
2430
2442 TRange<T> operator*(int32_t value)
2443 {
2444 TRange<T> trReturn(this);
2445 trReturn *= value;
2446 return trReturn;
2447 }
2448
2460 TRange<T> operator*(int64_t value)
2461 {
2462 TRange<T> trReturn(this);
2463 trReturn *= value;
2464 return trReturn;
2465 }
2466
2478 TRange<T> operator*(float value)
2479 {
2480 TRange<T> trReturn(this);
2481 trReturn *= value;
2482 return trReturn;
2483 }
2484
2496 TRange<T> operator*(double value)
2497 {
2498 TRange<T> trReturn(this);
2499 trReturn *= value;
2500 return trReturn;
2501 }
2502
2514 TRange<T> operator*(const TRange<int32_t>& tr)
2515 {
2516 TRange<T> trReturn(this);
2517 trReturn *= tr;
2518 return trReturn;
2519 }
2520
2532 TRange<T> operator*(const TRange<int64_t>& tr)
2533 {
2534 TRange<T> trReturn(this);
2535 trReturn *= tr;
2536 return trReturn;
2537 }
2538
2550 TRange<T> operator*(const TRange<float>& tr)
2551 {
2552 TRange<T> trReturn(this);
2553 trReturn *= tr;
2554 return trReturn;
2555 }
2556
2568 TRange<T> operator*(const TRange<double>& tr)
2569 {
2570 TRange<T> trReturn(this);
2571 trReturn *= tr;
2572 return trReturn;
2573 }
2574
2586 TRange<T> operator/(int32_t value)
2587 {
2588 TRange<T> trReturn(this);
2589 trReturn /= value;
2590 return trReturn;
2591 }
2592
2604 TRange<T> operator/(int64_t value)
2605 {
2606 TRange<T> trReturn(this);
2607 trReturn /= value;
2608 return trReturn;
2609 }
2610
2622 TRange<T> operator/(float value)
2623 {
2624 TRange<T> trReturn(this);
2625 trReturn /= value;
2626 return trReturn;
2627 }
2628
2640 TRange<T> operator/(double value)
2641 {
2642 TRange<T> trReturn(this);
2643 trReturn /= value;
2644 return trReturn;
2645 }
2646
2658 TRange<T> operator/(const TRange<int32_t>& tr)
2659 {
2660 TRange<T> trReturn(this);
2661 trReturn /= tr;
2662 return trReturn;
2663 }
2664
2676 TRange<T> operator/(const TRange<int64_t>& tr)
2677 {
2678 TRange<T> trReturn(this);
2679 trReturn /= tr;
2680 return trReturn;
2681 }
2682
2694 TRange<T> operator/(const TRange<float>& tr)
2695 {
2696 TRange<T> trReturn(this);
2697 trReturn /= tr;
2698 return trReturn;
2699 }
2700
2712 TRange<T> operator/(const TRange<double>& tr)
2713 {
2714 TRange<T> trReturn(this);
2715 trReturn /= tr;
2716 return trReturn;
2717 }
2718
2732 friend TRange<T> operator+(int32_t value, const TRange<T>& tr)
2733 {
2734 return TRange<T>(TRange<double>(tr) + value);
2735 }
2736
2750 friend TRange<T> operator+(int64_t value, const TRange<T>& tr)
2751 {
2752 return TRange<T>(TRange<double>(tr) + value);
2753 }
2754
2768 friend TRange<T> operator+(float value, const TRange<T>& tr)
2769 {
2770 return TRange<T>(TRange<double>(tr) + value);
2771 }
2772
2786 friend TRange<T> operator+(double value, const TRange<T>& tr)
2787 {
2788 return TRange<T>(TRange<double>(tr) + value);
2789 }
2790
2804 friend TRange<T> operator-(int32_t value, const TRange<T>& tr)
2805 {
2806 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)));
2807 }
2808
2822 friend TRange<T> operator-(int64_t value, const TRange<T>& tr)
2823 {
2824 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)));
2825 }
2826
2840 friend TRange<T> operator-(float value, const TRange<T>& tr)
2841 {
2842 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)));
2843 }
2844
2858 friend TRange<T> operator-(double value, const TRange<T>& tr)
2859 {
2860 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)));
2861 }
2862
2876 friend TRange<T> operator*(int32_t value, const TRange<T>& tr)
2877 {
2878 return TRange<T>(TRange<double>(tr) * value);
2879 }
2880
2894 friend TRange<T> operator*(int64_t value, const TRange<T>& tr)
2895 {
2896 return TRange<T>(TRange<double>(tr) * value);
2897 }
2898
2912 friend TRange<T> operator*(float value, const TRange<T>& tr)
2913 {
2914 return TRange<T>(TRange<double>(tr) * value);
2915 }
2916
2930 friend TRange<T> operator*(double value, const TRange<T>& tr)
2931 {
2932 return TRange<T>(TRange<double>(tr) * value);
2933 }
2934
2948 friend TRange<T> operator/(int32_t value, const TRange<T>& tr)
2949 {
2950 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)));
2951 }
2952
2966 friend TRange<T> operator/(int64_t value, const TRange<T>& tr)
2967 {
2968 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)));
2969 }
2970
2984 friend TRange<T> operator/(float value, const TRange<T>& tr)
2985 {
2986 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)));
2987 }
2988
3002 friend TRange<T> operator/(double value, const TRange<T>& tr)
3003 {
3004 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)));
3005 }
3006 };
3007 #pragma pack(pop)
3008
3009 typedef TRange<int16_t> TRangeS;
3010 typedef TRange<uint16_t> TRangeUS;
3011 typedef TRange<int32_t> TRangeL;
3012 typedef TRange<uint32_t> TRangeUL;
3013 typedef TRange<int64_t> TRangeLL;
3014 typedef TRange<uint64_t> TRangeULL;
3015 typedef TRange<float> TRangeF;
3016 typedef TRange<double> TRangeD;
3017 }
3018}
FLImaging::Base::TPoint
Simplified class representing a point.
Definition TPoint.h:37
FLImaging::Base::TRange::operator/
friend TRange< T > operator/(int32_t value, const TRange< T > &tr)
Division operator.
Definition TRange.h:2948
FLImaging::Base::TRange::operator+=
const TRange< T > & operator+=(int64_t value)
Addition assignment operator.
Definition TRange.h:1565
FLImaging::Base::TRange::operator!=
bool operator!=(const TRange< double > &tr)
Inequality operator.
Definition TRange.h:1530
FLImaging::Base::TRange::Set
void Set(const TRange< int32_t > &tr)
Sets the range from another TRange object.
Definition TRange.h:773
FLImaging::Base::TRange::operator=
const TRange< T > & operator=(const TRange< double > &tr)
Assignment operator.
Definition TRange.h:1400
FLImaging::Base::TRange::Set
void Set(const TPoint< int64_t > *pTpLB, const TPoint< int64_t > *pTpUB)
Sets the range using pointers to lower and upper bound points.
Definition TRange.h:1138
FLImaging::Base::TRange::TRange
TRange(T tLBX, T tLBY, T tUBX, T tUBY)
Constructs a range using lower and upper bound coordinates.
Definition TRange.h:72
FLImaging::Base::TRange::TRange
TRange(const TPoint< uint32_t > *pTpLB, const TPoint< uint32_t > *pTpUB)
Constructs a range using pointers to lower and upper bound points.
Definition TRange.h:500
FLImaging::Base::TRange::Set
void Set(const TPoint< int32_t > &tpLB, const TPoint< int32_t > &tpUB)
Sets the range using lower and upper bound points.
Definition TRange.h:1047
FLImaging::Base::TRange::TRange
TRange(const TPoint< int64_t > &tpLB, const TPoint< int64_t > &tpUB)
Constructs a range using lower and upper bound points.
Definition TRange.h:520
FLImaging::Base::TRange::Set
void Set(const TPoint< uint32_t > &tpLB, const TPoint< uint32_t > &tpUB)
Sets the range using lower and upper bound points.
Definition TRange.h:1084
FLImaging::Base::TRange::Set
void Set(const TRange< float > &tr)
Sets the range from another TRange object.
Definition TRange.h:905
FLImaging::Base::TRange::operator*=
const TRange< T > & operator*=(const TRange< double > &tr)
Multiplication assignment operator.
Definition TRange.h:1983
FLImaging::Base::TRange::operator=
const TRange< T > & operator=(const TRange< int64_t > &tr)
Assignment operator.
Definition TRange.h:1364
FLImaging::Base::TRange::operator*
TRange< T > operator*(double value)
Multiplication operator.
Definition TRange.h:2496
FLImaging::Base::TRange::operator*
friend TRange< T > operator*(int64_t value, const TRange< T > &tr)
Multiplication operator.
Definition TRange.h:2894
FLImaging::Base::TRange::operator==
bool operator==(const TRange< int64_t > &tr)
Equality operator.
Definition TRange.h:1434
FLImaging::Base::TRange::operator/
TRange< T > operator/(int32_t value)
Division operator.
Definition TRange.h:2586
FLImaging::Base::TRange::operator+
TRange< T > operator+(int32_t value)
Addition operator.
Definition TRange.h:2154
FLImaging::Base::TRange::operator*
friend TRange< T > operator*(int32_t value, const TRange< T > &tr)
Multiplication operator.
Definition TRange.h:2876
FLImaging::Base::TRange::Set
void Set(const TPoint< uint16_t > &tpLB, const TPoint< uint16_t > &tpUB)
Sets the range using lower and upper bound points.
Definition TRange.h:1010
FLImaging::Base::TRange::operator*
TRange< T > operator*(int64_t value)
Multiplication operator.
Definition TRange.h:2460
FLImaging::Base::TRange::TRange
TRange(const TRange< int64_t > *pTr)
Copy constructor.
Definition TRange.h:253
FLImaging::Base::TRange::TRange
TRange(const TRange< float > *pTr)
Copy constructor.
Definition TRange.h:319
FLImaging::Base::TRange::TRange
TRange(const TPoint< double > *pTpLB, const TPoint< double > *pTpUB)
Constructs a range using pointers to lower and upper bound points.
Definition TRange.h:648
FLImaging::Base::TRange::operator-=
const TRange< T > & operator-=(const TRange< double > &tr)
Subtraction assignment operator.
Definition TRange.h:1831
FLImaging::Base::TRange::operator-
friend TRange< T > operator-(int64_t value, const TRange< T > &tr)
Subtraction operator.
Definition TRange.h:2822
FLImaging::Base::TRange::Set
void Set(const TRange< uint32_t > &tr)
Sets the range from another TRange object.
Definition TRange.h:806
FLImaging::Base::TRange::TRange
TRange(const TRange< double > &tr)
Copy constructor.
Definition TRange.h:337
FLImaging::Base::TRange::Set
void Set(const TPoint< float > &tpLB, const TPoint< float > &tpUB)
Sets the range using lower and upper bound points.
Definition TRange.h:1195
FLImaging::Base::TRange::Set
void Set(const TPoint< uint64_t > *pTpLB, const TPoint< uint64_t > *pTpUB)
Sets the range using pointers to lower and upper bound points.
Definition TRange.h:1175
FLImaging::Base::TRange::operator*=
const TRange< T > & operator*=(const TRange< float > &tr)
Multiplication assignment operator.
Definition TRange.h:1964
FLImaging::Base::TRange::Set
void Set(const TPoint< int32_t > *pTpLB, const TPoint< int32_t > *pTpUB)
Sets the range using pointers to lower and upper bound points.
Definition TRange.h:1064
FLImaging::Base::TRange::operator/=
const TRange< T > & operator/=(int64_t value)
Division assignment operator.
Definition TRange.h:2021
FLImaging::Base::TRange::TRange
TRange(const TPoint< int32_t > *pTpLB, const TPoint< int32_t > *pTpUB)
Constructs a range using pointers to lower and upper bound points.
Definition TRange.h:463
FLImaging::Base::TRange::operator-
friend TRange< T > operator-(float value, const TRange< T > &tr)
Subtraction operator.
Definition TRange.h:2840
FLImaging::Base::TRange::operator!=
bool operator!=(const TRange< int32_t > &tr)
Inequality operator.
Definition TRange.h:1482
FLImaging::Base::TRange::Set
void Set(const TRange< uint16_t > *pTr)
Sets the range from a TRange pointer.
Definition TRange.h:755
FLImaging::Base::TRange::operator=
const TRange< T > & operator=(double value)
Assignment operator.
Definition TRange.h:1327
FLImaging::Base::TRange::operator/=
const TRange< T > & operator/=(float value)
Division assignment operator.
Definition TRange.h:2040
FLImaging::Base::TRange::operator/
TRange< T > operator/(const TRange< int64_t > &tr)
Division operator.
Definition TRange.h:2676
FLImaging::Base::TRange::operator+
TRange< T > operator+(const TRange< int64_t > &tr)
Addition operator.
Definition TRange.h:2244
FLImaging::Base::TRange::operator=
const TRange< T > & operator=(float value)
Assignment operator.
Definition TRange.h:1308
FLImaging::Base::TRange::Set
void Set(const TRange< int16_t > &tr)
Sets the range from another TRange object.
Definition TRange.h:707
FLImaging::Base::TRange::Set
void Set(const TRange< int32_t > *pTr)
Sets the range from a TRange pointer.
Definition TRange.h:788
FLImaging::Base::TRange::TRange
TRange(const TPoint< int16_t > &tpLB, const TPoint< int16_t > &tpUB)
Constructs a range using lower and upper bound points.
Definition TRange.h:372
FLImaging::Base::TRange::Set
void Set(const TRange< int16_t > *pTr)
Sets the range from a TRange pointer.
Definition TRange.h:722
FLImaging::Base::TRange::TRange
TRange(const TRange< uint64_t > *pTr)
Copy constructor.
Definition TRange.h:286
FLImaging::Base::TRange::TRange
TRange()
Default constructor.
Definition TRange.h:53
FLImaging::Base::TRange::operator*=
const TRange< T > & operator*=(const TRange< int32_t > &tr)
Multiplication assignment operator.
Definition TRange.h:1926
FLImaging::Base::TRange::operator=
const TRange< T > & operator=(int32_t value)
Assignment operator.
Definition TRange.h:1270
FLImaging::Base::TRange::operator*
friend TRange< T > operator*(float value, const TRange< T > &tr)
Multiplication operator.
Definition TRange.h:2912
FLImaging::Base::TRange::operator/
TRange< T > operator/(const TRange< double > &tr)
Division operator.
Definition TRange.h:2712
FLImaging::Base::TRange::operator-
TRange< T > operator-(int64_t value)
Subtraction operator.
Definition TRange.h:2316
FLImaging::Base::TRange::Set
void Set(const TPoint< uint64_t > &tpLB, const TPoint< uint64_t > &tpUB)
Sets the range using lower and upper bound points.
Definition TRange.h:1158
FLImaging::Base::TRange::operator-=
const TRange< T > & operator-=(double value)
Subtraction assignment operator.
Definition TRange.h:1755
FLImaging::Base::TRange::Set
void Set(const TRect< T > &tr)
Sets the range from a rectangle.
Definition TRange.h:690
FLImaging::Base::TRange::operator=
const TRange< T > & operator=(int64_t value)
Assignment operator.
Definition TRange.h:1289
FLImaging::Base::TRange::Set
void Set(const TRange< uint16_t > &tr)
Sets the range from another TRange object.
Definition TRange.h:740
FLImaging::Base::TRange::operator==
bool operator==(const TRange< double > &tr)
Equality operator.
Definition TRange.h:1466
FLImaging::Base::TRange::Set
void Set(T tLBX, T tLBY, T tUBX, T tUBY)
Sets the range using lower and upper bound coordinates.
Definition TRange.h:673
FLImaging::Base::TRange::Set
void Set(const TPoint< uint16_t > *pTpLB, const TPoint< uint16_t > *pTpUB)
Sets the range using pointers to lower and upper bound points.
Definition TRange.h:1027
FLImaging::Base::TRange::TRange
TRange(const TPoint< uint16_t > &tpLB, const TPoint< uint16_t > &tpUB)
Constructs a range using lower and upper bound points.
Definition TRange.h:409
FLImaging::Base::TRange::operator-
TRange< T > operator-(const TRange< double > &tr)
Subtraction operator.
Definition TRange.h:2424
FLImaging::Base::TRange::operator+
TRange< T > operator+(const TRange< double > &tr)
Addition operator.
Definition TRange.h:2280
FLImaging::Base::TRange::operator/
friend TRange< T > operator/(int64_t value, const TRange< T > &tr)
Division operator.
Definition TRange.h:2966
FLImaging::Base::TRange::TRange
TRange(const TRange< float > &tr)
Copy constructor.
Definition TRange.h:304
FLImaging::Base::TRange::Set
void Set(const TPoint< float > *pTpLB, const TPoint< float > *pTpUB)
Sets the range using pointers to lower and upper bound points.
Definition TRange.h:1212
FLImaging::Base::TRange::operator*
TRange< T > operator*(const TRange< int32_t > &tr)
Multiplication operator.
Definition TRange.h:2514
FLImaging::Base::TRange::TRange
TRange(const TPoint< int16_t > *pTpLB, const TPoint< int16_t > *pTpUB)
Constructs a range using pointers to lower and upper bound points.
Definition TRange.h:389
FLImaging::Base::TRange::operator+=
const TRange< T > & operator+=(const TRange< double > &tr)
Addition assignment operator.
Definition TRange.h:1679
FLImaging::Base::TRange::operator/
TRange< T > operator/(const TRange< float > &tr)
Division operator.
Definition TRange.h:2694
FLImaging::Base::TRange::Set
void Set(const TPoint< int64_t > &tpLB, const TPoint< int64_t > &tpUB)
Sets the range using lower and upper bound points.
Definition TRange.h:1121
FLImaging::Base::TRange::TRange
TRange(const TRange< int32_t > &tr)
Copy constructor.
Definition TRange.h:172
FLImaging::Base::TRange::TRange
TRange(const TRange< int32_t > *pTr)
Copy constructor.
Definition TRange.h:187
FLImaging::Base::TRange::TRange
TRange(const TPoint< uint32_t > &tpLB, const TPoint< uint32_t > &tpUB)
Constructs a range using lower and upper bound points.
Definition TRange.h:483
FLImaging::Base::TRange::TRange
TRange(const TRange< uint64_t > &tr)
Copy constructor.
Definition TRange.h:271
FLImaging::Base::TRange::operator+
TRange< T > operator+(int64_t value)
Addition operator.
Definition TRange.h:2172
FLImaging::Base::TRange::operator*
TRange< T > operator*(const TRange< double > &tr)
Multiplication operator.
Definition TRange.h:2568
FLImaging::Base::TRange::operator-=
const TRange< T > & operator-=(const TRange< int32_t > &tr)
Subtraction assignment operator.
Definition TRange.h:1774
FLImaging::Base::TRange< int16_t >::tpPoints
TPoint< int16_t > tpPoints[2]
Definition TRange.h:44
FLImaging::Base::TRange::Set
void Set(const TPoint< double > &tpLB, const TPoint< double > &tpUB)
Sets the range using lower and upper bound points.
Definition TRange.h:1232
FLImaging::Base::TRange::TRange
TRange(const TRange< int16_t > *pTr)
Copy constructor.
Definition TRange.h:121
FLImaging::Base::TRange::TRange
TRange(const TRange< uint32_t > &tr)
Copy constructor.
Definition TRange.h:205
FLImaging::Base::TRange::operator-
TRange< T > operator-(const TRange< int32_t > &tr)
Subtraction operator.
Definition TRange.h:2370
FLImaging::Base::TRange::operator/
TRange< T > operator/(double value)
Division operator.
Definition TRange.h:2640
FLImaging::Base::TRange::TRange
TRange(const TPoint< int32_t > &tpLB, const TPoint< int32_t > &tpUB)
Constructs a range using lower and upper bound points.
Definition TRange.h:446
FLImaging::Base::TRange::TRange
TRange(const TRange< uint16_t > &tr)
Copy constructor.
Definition TRange.h:139
FLImaging::Base::TRange::operator*
TRange< T > operator*(int32_t value)
Multiplication operator.
Definition TRange.h:2442
FLImaging::Base::TRange::operator/
TRange< T > operator/(float value)
Division operator.
Definition TRange.h:2622
FLImaging::Base::TRange::operator/
friend TRange< T > operator/(float value, const TRange< T > &tr)
Division operator.
Definition TRange.h:2984
FLImaging::Base::TRange::operator-=
const TRange< T > & operator-=(int32_t value)
Subtraction assignment operator.
Definition TRange.h:1698
FLImaging::Base::TRange::operator/=
const TRange< T > & operator/=(const TRange< double > &tr)
Division assignment operator.
Definition TRange.h:2135
FLImaging::Base::TRange::operator-
TRange< T > operator-(double value)
Subtraction operator.
Definition TRange.h:2352
FLImaging::Base::TRange::operator!=
bool operator!=(const TRange< float > &tr)
Inequality operator.
Definition TRange.h:1514
FLImaging::Base::TRange::operator=
const TRange< T > & operator=(const TRange< float > &tr)
Assignment operator.
Definition TRange.h:1382
FLImaging::Base::TRange::Set
void Set(const TRange< int64_t > *pTr)
Sets the range from a TRange pointer.
Definition TRange.h:854
FLImaging::Base::TRange::operator+
TRange< T > operator+(float value)
Addition operator.
Definition TRange.h:2190
FLImaging::Base::TRange::TRange
TRange(const TRange< int16_t > &tr)
Copy constructor.
Definition TRange.h:106
FLImaging::Base::TRange::operator*=
const TRange< T > & operator*=(int32_t value)
Multiplication assignment operator.
Definition TRange.h:1850
FLImaging::Base::TRange::operator*
friend TRange< T > operator*(double value, const TRange< T > &tr)
Multiplication operator.
Definition TRange.h:2930
FLImaging::Base::TRange::operator+
TRange< T > operator+(const TRange< int32_t > &tr)
Addition operator.
Definition TRange.h:2226
FLImaging::Base::TRange::operator==
bool operator==(const TRange< float > &tr)
Equality operator.
Definition TRange.h:1450
FLImaging::Base::TRange::Set
void Set(const TPoint< uint32_t > *pTpLB, const TPoint< uint32_t > *pTpUB)
Sets the range using pointers to lower and upper bound points.
Definition TRange.h:1101
FLImaging::Base::TRange::operator/
TRange< T > operator/(const TRange< int32_t > &tr)
Division operator.
Definition TRange.h:2658
FLImaging::Base::TRange::Set
void Set(const TRange< uint32_t > *pTr)
Sets the range from a TRange pointer.
Definition TRange.h:821
FLImaging::Base::TRange::operator/=
const TRange< T > & operator/=(const TRange< int64_t > &tr)
Division assignment operator.
Definition TRange.h:2097
FLImaging::Base::TRange::operator/
friend TRange< T > operator/(double value, const TRange< T > &tr)
Division operator.
Definition TRange.h:3002
FLImaging::Base::TRange::operator*=
const TRange< T > & operator*=(float value)
Multiplication assignment operator.
Definition TRange.h:1888
FLImaging::Base::TRange::Set
void Set(const TPoint< double > *pTpLB, const TPoint< double > *pTpUB)
Sets the range using pointers to lower and upper bound points.
Definition TRange.h:1249
FLImaging::Base::TRange::TRange
TRange(const TRange< double > *pTr)
Copy constructor.
Definition TRange.h:352
FLImaging::Base::TRange::TRange
TRange(const TRect< T > &tr)
Constructs a range from a rectangle.
Definition TRange.h:89
FLImaging::Base::TRange::Set
void Set(const TRange< float > *pTr)
Sets the range from a TRange pointer.
Definition TRange.h:920
FLImaging::Base::TRange::operator==
bool operator==(const TRange< int32_t > &tr)
Equality operator.
Definition TRange.h:1418
FLImaging::Base::TRange::operator+=
const TRange< T > & operator+=(float value)
Addition assignment operator.
Definition TRange.h:1584
FLImaging::Base::TRange::operator*
TRange< T > operator*(float value)
Multiplication operator.
Definition TRange.h:2478
FLImaging::Base::TRange::TRange
TRange(const TPoint< uint64_t > &tpLB, const TPoint< uint64_t > &tpUB)
Constructs a range using lower and upper bound points.
Definition TRange.h:557
FLImaging::Base::TRange::operator/=
const TRange< T > & operator/=(const TRange< int32_t > &tr)
Division assignment operator.
Definition TRange.h:2078
FLImaging::Base::TRange::TRange
TRange(const TRange< uint32_t > *pTr)
Copy constructor.
Definition TRange.h:220
FLImaging::Base::TRange::operator*=
const TRange< T > & operator*=(const TRange< int64_t > &tr)
Multiplication assignment operator.
Definition TRange.h:1945
FLImaging::Base::TRange::operator-
friend TRange< T > operator-(double value, const TRange< T > &tr)
Subtraction operator.
Definition TRange.h:2858
FLImaging::Base::TRange::operator-
TRange< T > operator-(const TRange< float > &tr)
Subtraction operator.
Definition TRange.h:2406
FLImaging::Base::TRange::operator+
TRange< T > operator+(const TRange< float > &tr)
Addition operator.
Definition TRange.h:2262
FLImaging::Base::TRange::TRange
TRange(const TRange< uint16_t > *pTr)
Copy constructor.
Definition TRange.h:154
FLImaging::Base::TRange::operator-=
const TRange< T > & operator-=(const TRange< int64_t > &tr)
Subtraction assignment operator.
Definition TRange.h:1793
FLImaging::Base::TRange::operator+
friend TRange< T > operator+(float value, const TRange< T > &tr)
Addition operator.
Definition TRange.h:2768
FLImaging::Base::TRange::TRange
TRange(const TPoint< int64_t > *pTpLB, const TPoint< int64_t > *pTpUB)
Constructs a range using pointers to lower and upper bound points.
Definition TRange.h:537
FLImaging::Base::TRange::Set
void Set(const TRange< int64_t > &tr)
Sets the range from another TRange object.
Definition TRange.h:839
FLImaging::Base::TRange::Set
void Set(const TPoint< int16_t > &tpLB, const TPoint< int16_t > &tpUB)
Sets the range using lower and upper bound points.
Definition TRange.h:973
FLImaging::Base::TRange::operator-
friend TRange< T > operator-(int32_t value, const TRange< T > &tr)
Subtraction operator.
Definition TRange.h:2804
FLImaging::Base::TRange::operator/=
const TRange< T > & operator/=(double value)
Division assignment operator.
Definition TRange.h:2059
FLImaging::Base::TRange::operator/=
const TRange< T > & operator/=(int32_t value)
Division assignment operator.
Definition TRange.h:2002
FLImaging::Base::TRange::operator-
TRange< T > operator-(int32_t value)
Subtraction operator.
Definition TRange.h:2298
FLImaging::Base::TRange::TRange
TRange(const TPoint< double > &tpLB, const TPoint< double > &tpUB)
Constructs a range using lower and upper bound points.
Definition TRange.h:631
FLImaging::Base::TRange::operator+
friend TRange< T > operator+(double value, const TRange< T > &tr)
Addition operator.
Definition TRange.h:2786
FLImaging::Base::TRange::operator+=
const TRange< T > & operator+=(const TRange< float > &tr)
Addition assignment operator.
Definition TRange.h:1660
FLImaging::Base::TRange::operator=
const TRange< T > & operator=(const TRange< int32_t > &tr)
Assignment operator.
Definition TRange.h:1346
FLImaging::Base::TRange::operator+
friend TRange< T > operator+(int64_t value, const TRange< T > &tr)
Addition operator.
Definition TRange.h:2750
FLImaging::Base::TRange::operator+=
const TRange< T > & operator+=(double value)
Addition assignment operator.
Definition TRange.h:1603
FLImaging::Base::TRange::operator-=
const TRange< T > & operator-=(int64_t value)
Subtraction assignment operator.
Definition TRange.h:1717
FLImaging::Base::TRange::operator+
TRange< T > operator+(double value)
Addition operator.
Definition TRange.h:2208
FLImaging::Base::TRange::Set
void Set(const TPoint< int16_t > *pTpLB, const TPoint< int16_t > *pTpUB)
Sets the range using pointers to lower and upper bound points.
Definition TRange.h:990
FLImaging::Base::TRange::Set
void Set(const TRange< uint64_t > *pTr)
Sets the range from a TRange pointer.
Definition TRange.h:887
FLImaging::Base::TRange::operator*
TRange< T > operator*(const TRange< int64_t > &tr)
Multiplication operator.
Definition TRange.h:2532
FLImaging::Base::TRange::operator-
TRange< T > operator-(float value)
Subtraction operator.
Definition TRange.h:2334
FLImaging::Base::TRange::Set
void Set(const TRange< double > *pTr)
Sets the range from a TRange pointer.
Definition TRange.h:953
FLImaging::Base::TRange::operator+
friend TRange< T > operator+(int32_t value, const TRange< T > &tr)
Addition operator.
Definition TRange.h:2732
FLImaging::Base::TRange::operator!=
bool operator!=(const TRange< int64_t > &tr)
Inequality operator.
Definition TRange.h:1498
FLImaging::Base::TRange::operator*=
const TRange< T > & operator*=(double value)
Multiplication assignment operator.
Definition TRange.h:1907
FLImaging::Base::TRange::Set
void Set(const TRange< double > &tr)
Sets the range from another TRange object.
Definition TRange.h:938
FLImaging::Base::TRange::TRange
TRange(const TPoint< uint16_t > *pTpLB, const TPoint< uint16_t > *pTpUB)
Constructs a range using pointers to lower and upper bound points.
Definition TRange.h:426
FLImaging::Base::TRange::operator-=
const TRange< T > & operator-=(const TRange< float > &tr)
Subtraction assignment operator.
Definition TRange.h:1812
FLImaging::Base::TRange::operator*=
const TRange< T > & operator*=(int64_t value)
Multiplication assignment operator.
Definition TRange.h:1869
FLImaging::Base::TRange::TRange
TRange(const TPoint< float > *pTpLB, const TPoint< float > *pTpUB)
Constructs a range using pointers to lower and upper bound points.
Definition TRange.h:611
FLImaging::Base::TRange::operator-
TRange< T > operator-(const TRange< int64_t > &tr)
Subtraction operator.
Definition TRange.h:2388
FLImaging::Base::TRange::operator-=
const TRange< T > & operator-=(float value)
Subtraction assignment operator.
Definition TRange.h:1736
FLImaging::Base::TRange::operator+=
const TRange< T > & operator+=(const TRange< int64_t > &tr)
Addition assignment operator.
Definition TRange.h:1641
FLImaging::Base::TRange::operator*
TRange< T > operator*(const TRange< float > &tr)
Multiplication operator.
Definition TRange.h:2550
FLImaging::Base::TRange::operator+=
const TRange< T > & operator+=(const TRange< int32_t > &tr)
Addition assignment operator.
Definition TRange.h:1622
FLImaging::Base::TRange::TRange
TRange(const TPoint< uint64_t > *pTpLB, const TPoint< uint64_t > *pTpUB)
Constructs a range using pointers to lower and upper bound points.
Definition TRange.h:574
FLImaging::Base::TRange::Set
void Set(const TRange< uint64_t > &tr)
Sets the range from another TRange object.
Definition TRange.h:872
FLImaging::Base::TRange::TRange
TRange(const TRange< int64_t > &tr)
Copy constructor.
Definition TRange.h:238
FLImaging::Base::TRange::operator+=
const TRange< T > & operator+=(int32_t value)
Addition assignment operator.
Definition TRange.h:1546
FLImaging::Base::TRange::TRange
TRange(const TPoint< float > &tpLB, const TPoint< float > &tpUB)
Constructs a range using lower and upper bound points.
Definition TRange.h:594
FLImaging::Base::TRange::operator/=
const TRange< T > & operator/=(const TRange< float > &tr)
Division assignment operator.
Definition TRange.h:2116
FLImaging::Base::TRange::operator/
TRange< T > operator/(int64_t value)
Division operator.
Definition TRange.h:2604
FLImaging::Base::TRect
Simplified class representing a rectangle.
Definition TRect.h:37
FLImaging::Base::TRect::bottom
T bottom
Definition TRect.h:61
FLImaging::Base::TRect::right
T right
Definition TRect.h:55
FLImaging::Base::TRect::left
T left
Definition TRect.h:43
FLImaging::Base::TRect::top
T top
Definition TRect.h:49
FLImaging::Base
Definition AESCryptography.h:18
Generated on for FLImaging by doxygen 1.17.0