FLImaging 7.6.11.1
TQuad.h
1#pragma once
2
10
11#include "FLLibTags.h"
12#include "TPoint.h"
13
15namespace FLImaging
16{
18 namespace Base
19 {
31 #pragma pack(push, 1)
32 template <typename T>
33 class FL_EXPORT TQuad
34 {
35 public:
40 TPoint<T> tpPoints[4];
41
42
50 TQuad()
51 {
52 }
53
77 TQuad(T tLTX, T tLTY, T tRTX, T tRTY, T tRBX, T tRBY, T tLBX, T tLBY)
78 {
79 tpPoints[0].x = tLTX;
80 tpPoints[0].y = tLTY;
81 tpPoints[1].x = tRTX;
82 tpPoints[1].y = tRTY;
83 tpPoints[2].x = tRBX;
84 tpPoints[2].y = tRBY;
85 tpPoints[3].x = tLBX;
86 tpPoints[3].y = tLBY;
87 }
88
98 TQuad(const TQuad<int8_t>& tq)
99 {
100 tpPoints[0].Set(tq.tpPoints[0]);
101 tpPoints[1].Set(tq.tpPoints[1]);
102 tpPoints[2].Set(tq.tpPoints[2]);
103 tpPoints[3].Set(tq.tpPoints[3]);
104 }
105
115 TQuad(const TQuad<int8_t>* pTq)
116 {
117 if(pTq)
118 {
119 tpPoints[0].Set(pTq->tpPoints[0]);
120 tpPoints[1].Set(pTq->tpPoints[1]);
121 tpPoints[2].Set(pTq->tpPoints[2]);
122 tpPoints[3].Set(pTq->tpPoints[3]);
123 }
124 }
125
135 TQuad(const TQuad<uint8_t>& tq)
136 {
137 tpPoints[0].Set(tq.tpPoints[0]);
138 tpPoints[1].Set(tq.tpPoints[1]);
139 tpPoints[2].Set(tq.tpPoints[2]);
140 tpPoints[3].Set(tq.tpPoints[3]);
141 }
142
152 TQuad(const TQuad<uint8_t>* pTq)
153 {
154 if(pTq)
155 {
156 tpPoints[0].Set(pTq->tpPoints[0]);
157 tpPoints[1].Set(pTq->tpPoints[1]);
158 tpPoints[2].Set(pTq->tpPoints[2]);
159 tpPoints[3].Set(pTq->tpPoints[3]);
160 }
161 }
162
172 TQuad(const TQuad<int16_t>& tq)
173 {
174 tpPoints[0].Set(tq.tpPoints[0]);
175 tpPoints[1].Set(tq.tpPoints[1]);
176 tpPoints[2].Set(tq.tpPoints[2]);
177 tpPoints[3].Set(tq.tpPoints[3]);
178 }
179
189 TQuad(const TQuad<int16_t>* pTq)
190 {
191 if(pTq)
192 {
193 tpPoints[0].Set(pTq->tpPoints[0]);
194 tpPoints[1].Set(pTq->tpPoints[1]);
195 tpPoints[2].Set(pTq->tpPoints[2]);
196 tpPoints[3].Set(pTq->tpPoints[3]);
197 }
198 }
199
209 TQuad(const TQuad<uint16_t>& tq)
210 {
211 tpPoints[0].Set(tq.tpPoints[0]);
212 tpPoints[1].Set(tq.tpPoints[1]);
213 tpPoints[2].Set(tq.tpPoints[2]);
214 tpPoints[3].Set(tq.tpPoints[3]);
215 }
216
226 TQuad(const TQuad<uint16_t>* pTq)
227 {
228 if(pTq)
229 {
230 tpPoints[0].Set(pTq->tpPoints[0]);
231 tpPoints[1].Set(pTq->tpPoints[1]);
232 tpPoints[2].Set(pTq->tpPoints[2]);
233 tpPoints[3].Set(pTq->tpPoints[3]);
234 }
235 }
236
246 TQuad(const TQuad<int32_t>& tq)
247 {
248 tpPoints[0].Set(tq.tpPoints[0]);
249 tpPoints[1].Set(tq.tpPoints[1]);
250 tpPoints[2].Set(tq.tpPoints[2]);
251 tpPoints[3].Set(tq.tpPoints[3]);
252 }
253
263 TQuad(const TQuad<int32_t>* pTq)
264 {
265 if(pTq)
266 {
267 tpPoints[0].Set(pTq->tpPoints[0]);
268 tpPoints[1].Set(pTq->tpPoints[1]);
269 tpPoints[2].Set(pTq->tpPoints[2]);
270 tpPoints[3].Set(pTq->tpPoints[3]);
271 }
272 }
273
283 TQuad(const TQuad<uint32_t>& tq)
284 {
285 tpPoints[0].Set(tq.tpPoints[0]);
286 tpPoints[1].Set(tq.tpPoints[1]);
287 tpPoints[2].Set(tq.tpPoints[2]);
288 tpPoints[3].Set(tq.tpPoints[3]);
289 }
290
300 TQuad(const TQuad<uint32_t>* pTq)
301 {
302 if(pTq)
303 {
304 tpPoints[0].Set(pTq->tpPoints[0]);
305 tpPoints[1].Set(pTq->tpPoints[1]);
306 tpPoints[2].Set(pTq->tpPoints[2]);
307 tpPoints[3].Set(pTq->tpPoints[3]);
308 }
309 }
310
320 TQuad(const TQuad<int64_t>& tq)
321 {
322 tpPoints[0].Set(tq.tpPoints[0]);
323 tpPoints[1].Set(tq.tpPoints[1]);
324 tpPoints[2].Set(tq.tpPoints[2]);
325 tpPoints[3].Set(tq.tpPoints[3]);
326 }
327
337 TQuad(const TQuad<int64_t>* pTq)
338 {
339 if(pTq)
340 {
341 tpPoints[0].Set(pTq->tpPoints[0]);
342 tpPoints[1].Set(pTq->tpPoints[1]);
343 tpPoints[2].Set(pTq->tpPoints[2]);
344 tpPoints[3].Set(pTq->tpPoints[3]);
345 }
346 }
347
357 TQuad(const TQuad<uint64_t>& tq)
358 {
359 tpPoints[0].Set(tq.tpPoints[0]);
360 tpPoints[1].Set(tq.tpPoints[1]);
361 tpPoints[2].Set(tq.tpPoints[2]);
362 tpPoints[3].Set(tq.tpPoints[3]);
363 }
364
374 TQuad(const TQuad<uint64_t>* pTq)
375 {
376 if(pTq)
377 {
378 tpPoints[0].Set(pTq->tpPoints[0]);
379 tpPoints[1].Set(pTq->tpPoints[1]);
380 tpPoints[2].Set(pTq->tpPoints[2]);
381 tpPoints[3].Set(pTq->tpPoints[3]);
382 }
383 }
384
394 TQuad(const TQuad<float>& tq)
395 {
396 tpPoints[0].Set(tq.tpPoints[0]);
397 tpPoints[1].Set(tq.tpPoints[1]);
398 tpPoints[2].Set(tq.tpPoints[2]);
399 tpPoints[3].Set(tq.tpPoints[3]);
400 }
401
411 TQuad(const TQuad<float>* pTq)
412 {
413 if(pTq)
414 {
415 tpPoints[0].Set(pTq->tpPoints[0]);
416 tpPoints[1].Set(pTq->tpPoints[1]);
417 tpPoints[2].Set(pTq->tpPoints[2]);
418 tpPoints[3].Set(pTq->tpPoints[3]);
419 }
420 }
421
431 TQuad(const TQuad<double>& tq)
432 {
433 tpPoints[0].Set(tq.tpPoints[0]);
434 tpPoints[1].Set(tq.tpPoints[1]);
435 tpPoints[2].Set(tq.tpPoints[2]);
436 tpPoints[3].Set(tq.tpPoints[3]);
437 }
438
448 TQuad(const TQuad<double>* pTq)
449 {
450 if(pTq)
451 {
452 tpPoints[0].Set(pTq->tpPoints[0]);
453 tpPoints[1].Set(pTq->tpPoints[1]);
454 tpPoints[2].Set(pTq->tpPoints[2]);
455 tpPoints[3].Set(pTq->tpPoints[3]);
456 }
457 }
458
474 TQuad(const TPoint<int8_t>& tpLT, const TPoint<int8_t>& tpRT, const TPoint<int8_t>& tpRB, const TPoint<int8_t>& tpLB)
475 {
476 tpPoints[0].Set(tpLT);
477 tpPoints[1].Set(tpRT);
478 tpPoints[2].Set(tpRB);
479 tpPoints[3].Set(tpLB);
480 }
481
497 TQuad(const TPoint<int8_t>* pTpLT, const TPoint<int8_t>* pTpRT, const TPoint<int8_t>* pTpRB, const TPoint<int8_t>* pTpLB)
498 {
499 if(pTpLT && pTpRT && pTpRB && pTpLB)
500 {
501 tpPoints[0].Set(pTpLT);
502 tpPoints[1].Set(pTpRT);
503 tpPoints[2].Set(pTpRB);
504 tpPoints[3].Set(pTpLB);
505 }
506 }
507
523 TQuad(const TPoint<uint8_t>& tpLT, const TPoint<uint8_t>& tpRT, const TPoint<uint8_t>& tpRB, const TPoint<uint8_t>& tpLB)
524 {
525 tpPoints[0].Set(tpLT);
526 tpPoints[1].Set(tpRT);
527 tpPoints[2].Set(tpRB);
528 tpPoints[3].Set(tpLB);
529 }
530
546 TQuad(const TPoint<uint8_t>* pTpLT, const TPoint<uint8_t>* pTpRT, const TPoint<uint8_t>* pTpRB, const TPoint<uint8_t>* pTpLB)
547 {
548 if(pTpLT && pTpRT && pTpRB && pTpLB)
549 {
550 tpPoints[0].Set(pTpLT);
551 tpPoints[1].Set(pTpRT);
552 tpPoints[2].Set(pTpRB);
553 tpPoints[3].Set(pTpLB);
554 }
555 }
556
572 TQuad(const TPoint<int16_t>& tpLT, const TPoint<int16_t>& tpRT, const TPoint<int16_t>& tpRB, const TPoint<int16_t>& tpLB)
573 {
574 tpPoints[0].Set(tpLT);
575 tpPoints[1].Set(tpRT);
576 tpPoints[2].Set(tpRB);
577 tpPoints[3].Set(tpLB);
578 }
579
595 TQuad(const TPoint<int16_t>* pTpLT, const TPoint<int16_t>* pTpRT, const TPoint<int16_t>* pTpRB, const TPoint<int16_t>* pTpLB)
596 {
597 if(pTpLT && pTpRT && pTpRB && pTpLB)
598 {
599 tpPoints[0].Set(pTpLT);
600 tpPoints[1].Set(pTpRT);
601 tpPoints[2].Set(pTpRB);
602 tpPoints[3].Set(pTpLB);
603 }
604 }
605
621 TQuad(const TPoint<uint16_t>& tpLT, const TPoint<uint16_t>& tpRT, const TPoint<uint16_t>& tpRB, const TPoint<uint16_t>& tpLB)
622 {
623 tpPoints[0].Set(tpLT);
624 tpPoints[1].Set(tpRT);
625 tpPoints[2].Set(tpRB);
626 tpPoints[3].Set(tpLB);
627 }
628
644 TQuad(const TPoint<uint16_t>* pTpLT, const TPoint<uint16_t>* pTpRT, const TPoint<uint16_t>* pTpRB, const TPoint<uint16_t>* pTpLB)
645 {
646 if(pTpLT && pTpRT && pTpRB && pTpLB)
647 {
648 tpPoints[0].Set(pTpLT);
649 tpPoints[1].Set(pTpRT);
650 tpPoints[2].Set(pTpRB);
651 tpPoints[3].Set(pTpLB);
652 }
653 }
654
670 TQuad(const TPoint<int32_t>& tpLT, const TPoint<int32_t>& tpRT, const TPoint<int32_t>& tpRB, const TPoint<int32_t>& tpLB)
671 {
672 tpPoints[0].Set(tpLT);
673 tpPoints[1].Set(tpRT);
674 tpPoints[2].Set(tpRB);
675 tpPoints[3].Set(tpLB);
676 }
677
693 TQuad(const TPoint<int32_t>* pTpLT, const TPoint<int32_t>* pTpRT, const TPoint<int32_t>* pTpRB, const TPoint<int32_t>* pTpLB)
694 {
695 if(pTpLT && pTpRT && pTpRB && pTpLB)
696 {
697 tpPoints[0].Set(pTpLT);
698 tpPoints[1].Set(pTpRT);
699 tpPoints[2].Set(pTpRB);
700 tpPoints[3].Set(pTpLB);
701 }
702 }
703
719 TQuad(const TPoint<uint32_t>& tpLT, const TPoint<uint32_t>& tpRT, const TPoint<uint32_t>& tpRB, const TPoint<uint32_t>& tpLB)
720 {
721 tpPoints[0].Set(tpLT);
722 tpPoints[1].Set(tpRT);
723 tpPoints[2].Set(tpRB);
724 tpPoints[3].Set(tpLB);
725 }
726
742 TQuad(const TPoint<uint32_t>* pTpLT, const TPoint<uint32_t>* pTpRT, const TPoint<uint32_t>* pTpRB, const TPoint<uint32_t>* pTpLB)
743 {
744 if(pTpLT && pTpRT && pTpRB && pTpLB)
745 {
746 tpPoints[0].Set(pTpLT);
747 tpPoints[1].Set(pTpRT);
748 tpPoints[2].Set(pTpRB);
749 tpPoints[3].Set(pTpLB);
750 }
751 }
752
768 TQuad(const TPoint<int64_t>& tpLT, const TPoint<int64_t>& tpRT, const TPoint<int64_t>& tpRB, const TPoint<int64_t>& tpLB)
769 {
770 tpPoints[0].Set(tpLT);
771 tpPoints[1].Set(tpRT);
772 tpPoints[2].Set(tpRB);
773 tpPoints[3].Set(tpLB);
774 }
775
791 TQuad(const TPoint<int64_t>* pTpLT, const TPoint<int64_t>* pTpRT, const TPoint<int64_t>* pTpRB, const TPoint<int64_t>* pTpLB)
792 {
793 if(pTpLT && pTpRT && pTpRB && pTpLB)
794 {
795 tpPoints[0].Set(pTpLT);
796 tpPoints[1].Set(pTpRT);
797 tpPoints[2].Set(pTpRB);
798 tpPoints[3].Set(pTpLB);
799 }
800 }
801
817 TQuad(const TPoint<uint64_t>& tpLT, const TPoint<uint64_t>& tpRT, const TPoint<uint64_t>& tpRB, const TPoint<uint64_t>& tpLB)
818 {
819 tpPoints[0].Set(tpLT);
820 tpPoints[1].Set(tpRT);
821 tpPoints[2].Set(tpRB);
822 tpPoints[3].Set(tpLB);
823 }
824
840 TQuad(const TPoint<uint64_t>* pTpLT, const TPoint<uint64_t>* pTpRT, const TPoint<uint64_t>* pTpRB, const TPoint<uint64_t>* pTpLB)
841 {
842 if(pTpLT && pTpRT && pTpRB && pTpLB)
843 {
844 tpPoints[0].Set(pTpLT);
845 tpPoints[1].Set(pTpRT);
846 tpPoints[2].Set(pTpRB);
847 tpPoints[3].Set(pTpLB);
848 }
849 }
850
866 TQuad(const TPoint<float>& tpLT, const TPoint<float>& tpRT, const TPoint<float>& tpRB, const TPoint<float>& tpLB)
867 {
868 tpPoints[0].Set(tpLT);
869 tpPoints[1].Set(tpRT);
870 tpPoints[2].Set(tpRB);
871 tpPoints[3].Set(tpLB);
872 }
873
889 TQuad(const TPoint<float>* pTpLT, const TPoint<float>* pTpRT, const TPoint<float>* pTpRB, const TPoint<float>* pTpLB)
890 {
891 if(pTpLT && pTpRT && pTpRB && pTpLB)
892 {
893 tpPoints[0].Set(pTpLT);
894 tpPoints[1].Set(pTpRT);
895 tpPoints[2].Set(pTpRB);
896 tpPoints[3].Set(pTpLB);
897 }
898 }
899
915 TQuad(const TPoint<double>& tpLT, const TPoint<double>& tpRT, const TPoint<double>& tpRB, const TPoint<double>& tpLB)
916 {
917 tpPoints[0].Set(tpLT);
918 tpPoints[1].Set(tpRT);
919 tpPoints[2].Set(tpRB);
920 tpPoints[3].Set(tpLB);
921 }
922
938 TQuad(const TPoint<double>* pTpLT, const TPoint<double>* pTpRT, const TPoint<double>* pTpRB, const TPoint<double>* pTpLB)
939 {
940 if(pTpLT && pTpRT && pTpRB && pTpLB)
941 {
942 tpPoints[0].Set(pTpLT);
943 tpPoints[1].Set(pTpRT);
944 tpPoints[2].Set(pTpRB);
945 tpPoints[3].Set(pTpLB);
946 }
947 }
948
949
973 void Set(T tLTX, T tLTY, T tRTX, T tRTY, T tRBX, T tRBY, T tLBX, T tLBY)
974 {
975 tpPoints[0].x = tLTX;
976 tpPoints[0].y = tLTY;
977 tpPoints[1].x = tRTX;
978 tpPoints[1].y = tRTY;
979 tpPoints[2].x = tRBX;
980 tpPoints[2].y = tRBY;
981 tpPoints[3].x = tLBX;
982 tpPoints[3].y = tLBY;
983 }
984
994 void Set(const TQuad<int8_t>& tq)
995 {
996 tpPoints[0].Set(tq.tpPoints[0]);
997 tpPoints[1].Set(tq.tpPoints[1]);
998 tpPoints[2].Set(tq.tpPoints[2]);
999 tpPoints[3].Set(tq.tpPoints[3]);
1000 }
1001
1011 void Set(const TQuad<int8_t>* pTq)
1012 {
1013 if(pTq)
1014 {
1015 tpPoints[0].Set(pTq->tpPoints[0]);
1016 tpPoints[1].Set(pTq->tpPoints[1]);
1017 tpPoints[2].Set(pTq->tpPoints[2]);
1018 tpPoints[3].Set(pTq->tpPoints[3]);
1019 }
1020 }
1021
1031 void Set(const TQuad<uint8_t>& tq)
1032 {
1033 tpPoints[0].Set(tq.tpPoints[0]);
1034 tpPoints[1].Set(tq.tpPoints[1]);
1035 tpPoints[2].Set(tq.tpPoints[2]);
1036 tpPoints[3].Set(tq.tpPoints[3]);
1037 }
1038
1048 void Set(const TQuad<uint8_t>* pTq)
1049 {
1050 if(pTq)
1051 {
1052 tpPoints[0].Set(pTq->tpPoints[0]);
1053 tpPoints[1].Set(pTq->tpPoints[1]);
1054 tpPoints[2].Set(pTq->tpPoints[2]);
1055 tpPoints[3].Set(pTq->tpPoints[3]);
1056 }
1057 }
1058
1068 void Set(const TQuad<int16_t>& tq)
1069 {
1070 tpPoints[0].Set(tq.tpPoints[0]);
1071 tpPoints[1].Set(tq.tpPoints[1]);
1072 tpPoints[2].Set(tq.tpPoints[2]);
1073 tpPoints[3].Set(tq.tpPoints[3]);
1074 }
1075
1085 void Set(const TQuad<int16_t>* pTq)
1086 {
1087 if(pTq)
1088 {
1089 tpPoints[0].Set(pTq->tpPoints[0]);
1090 tpPoints[1].Set(pTq->tpPoints[1]);
1091 tpPoints[2].Set(pTq->tpPoints[2]);
1092 tpPoints[3].Set(pTq->tpPoints[3]);
1093 }
1094 }
1095
1105 void Set(const TQuad<uint16_t>& tq)
1106 {
1107 tpPoints[0].Set(tq.tpPoints[0]);
1108 tpPoints[1].Set(tq.tpPoints[1]);
1109 tpPoints[2].Set(tq.tpPoints[2]);
1110 tpPoints[3].Set(tq.tpPoints[3]);
1111 }
1112
1122 void Set(const TQuad<uint16_t>* pTq)
1123 {
1124 if(pTq)
1125 {
1126 tpPoints[0].Set(pTq->tpPoints[0]);
1127 tpPoints[1].Set(pTq->tpPoints[1]);
1128 tpPoints[2].Set(pTq->tpPoints[2]);
1129 tpPoints[3].Set(pTq->tpPoints[3]);
1130 }
1131 }
1132
1142 void Set(const TQuad<int32_t>& tq)
1143 {
1144 tpPoints[0].Set(tq.tpPoints[0]);
1145 tpPoints[1].Set(tq.tpPoints[1]);
1146 tpPoints[2].Set(tq.tpPoints[2]);
1147 tpPoints[3].Set(tq.tpPoints[3]);
1148 }
1149
1159 void Set(const TQuad<int32_t>* pTq)
1160 {
1161 if(pTq)
1162 {
1163 tpPoints[0].Set(pTq->tpPoints[0]);
1164 tpPoints[1].Set(pTq->tpPoints[1]);
1165 tpPoints[2].Set(pTq->tpPoints[2]);
1166 tpPoints[3].Set(pTq->tpPoints[3]);
1167 }
1168 }
1169
1179 void Set(const TQuad<uint32_t>& tq)
1180 {
1181 tpPoints[0].Set(tq.tpPoints[0]);
1182 tpPoints[1].Set(tq.tpPoints[1]);
1183 tpPoints[2].Set(tq.tpPoints[2]);
1184 tpPoints[3].Set(tq.tpPoints[3]);
1185 }
1186
1196 void Set(const TQuad<uint32_t>* pTq)
1197 {
1198 if(pTq)
1199 {
1200 tpPoints[0].Set(pTq->tpPoints[0]);
1201 tpPoints[1].Set(pTq->tpPoints[1]);
1202 tpPoints[2].Set(pTq->tpPoints[2]);
1203 tpPoints[3].Set(pTq->tpPoints[3]);
1204 }
1205 }
1206
1216 void Set(const TQuad<int64_t>& tq)
1217 {
1218 tpPoints[0].Set(tq.tpPoints[0]);
1219 tpPoints[1].Set(tq.tpPoints[1]);
1220 tpPoints[2].Set(tq.tpPoints[2]);
1221 tpPoints[3].Set(tq.tpPoints[3]);
1222 }
1223
1233 void Set(const TQuad<int64_t>* pTq)
1234 {
1235 if(pTq)
1236 {
1237 tpPoints[0].Set(pTq->tpPoints[0]);
1238 tpPoints[1].Set(pTq->tpPoints[1]);
1239 tpPoints[2].Set(pTq->tpPoints[2]);
1240 tpPoints[3].Set(pTq->tpPoints[3]);
1241 }
1242 }
1243
1253 void Set(const TQuad<uint64_t>& tq)
1254 {
1255 tpPoints[0].Set(tq.tpPoints[0]);
1256 tpPoints[1].Set(tq.tpPoints[1]);
1257 tpPoints[2].Set(tq.tpPoints[2]);
1258 tpPoints[3].Set(tq.tpPoints[3]);
1259 }
1260
1270 void Set(const TQuad<uint64_t>* pTq)
1271 {
1272 if(pTq)
1273 {
1274 tpPoints[0].Set(pTq->tpPoints[0]);
1275 tpPoints[1].Set(pTq->tpPoints[1]);
1276 tpPoints[2].Set(pTq->tpPoints[2]);
1277 tpPoints[3].Set(pTq->tpPoints[3]);
1278 }
1279 }
1280
1290 void Set(const TQuad<float>& tq)
1291 {
1292 tpPoints[0].Set(tq.tpPoints[0]);
1293 tpPoints[1].Set(tq.tpPoints[1]);
1294 tpPoints[2].Set(tq.tpPoints[2]);
1295 tpPoints[3].Set(tq.tpPoints[3]);
1296 }
1297
1307 void Set(const TQuad<float>* pTq)
1308 {
1309 if(pTq)
1310 {
1311 tpPoints[0].Set(pTq->tpPoints[0]);
1312 tpPoints[1].Set(pTq->tpPoints[1]);
1313 tpPoints[2].Set(pTq->tpPoints[2]);
1314 tpPoints[3].Set(pTq->tpPoints[3]);
1315 }
1316 }
1317
1327 void Set(const TQuad<double>& tq)
1328 {
1329 tpPoints[0].Set(tq.tpPoints[0]);
1330 tpPoints[1].Set(tq.tpPoints[1]);
1331 tpPoints[2].Set(tq.tpPoints[2]);
1332 tpPoints[3].Set(tq.tpPoints[3]);
1333 }
1334
1344 void Set(const TQuad<double>* pTq)
1345 {
1346 if(pTq)
1347 {
1348 tpPoints[0].Set(pTq->tpPoints[0]);
1349 tpPoints[1].Set(pTq->tpPoints[1]);
1350 tpPoints[2].Set(pTq->tpPoints[2]);
1351 tpPoints[3].Set(pTq->tpPoints[3]);
1352 }
1353 }
1354
1355
1371 void Set(const TPoint<int8_t>& tpLT, const TPoint<int8_t>& tpRT, const TPoint<int8_t>& tpRB, const TPoint<int8_t>& tpLB)
1372 {
1373 tpPoints[0].Set(tpLT);
1374 tpPoints[1].Set(tpRT);
1375 tpPoints[2].Set(tpRB);
1376 tpPoints[3].Set(tpLB);
1377 }
1378
1394 void Set(const TPoint<int8_t>* pTpLT, const TPoint<int8_t>* pTpRT, const TPoint<int8_t>* pTpRB, const TPoint<int8_t>* pTpLB)
1395 {
1396 if(pTpLT && pTpRT && pTpRB && pTpLB)
1397 {
1398 tpPoints[0].Set(pTpLT);
1399 tpPoints[1].Set(pTpRT);
1400 tpPoints[2].Set(pTpRB);
1401 tpPoints[3].Set(pTpLB);
1402 }
1403 }
1404
1420 void Set(const TPoint<uint8_t>& tpLT, const TPoint<uint8_t>& tpRT, const TPoint<uint8_t>& tpRB, const TPoint<uint8_t>& tpLB)
1421 {
1422 tpPoints[0].Set(tpLT);
1423 tpPoints[1].Set(tpRT);
1424 tpPoints[2].Set(tpRB);
1425 tpPoints[3].Set(tpLB);
1426 }
1427
1443 void Set(const TPoint<uint8_t>* pTpLT, const TPoint<uint8_t>* pTpRT, const TPoint<uint8_t>* pTpRB, const TPoint<uint8_t>* pTpLB)
1444 {
1445 if(pTpLT && pTpRT && pTpRB && pTpLB)
1446 {
1447 tpPoints[0].Set(pTpLT);
1448 tpPoints[1].Set(pTpRT);
1449 tpPoints[2].Set(pTpRB);
1450 tpPoints[3].Set(pTpLB);
1451 }
1452 }
1453
1469 void Set(const TPoint<int16_t>& tpLT, const TPoint<int16_t>& tpRT, const TPoint<int16_t>& tpRB, const TPoint<int16_t>& tpLB)
1470 {
1471 tpPoints[0].Set(tpLT);
1472 tpPoints[1].Set(tpRT);
1473 tpPoints[2].Set(tpRB);
1474 tpPoints[3].Set(tpLB);
1475 }
1476
1492 void Set(const TPoint<int16_t>* pTpLT, const TPoint<int16_t>* pTpRT, const TPoint<int16_t>* pTpRB, const TPoint<int16_t>* pTpLB)
1493 {
1494 if(pTpLT && pTpRT && pTpRB && pTpLB)
1495 {
1496 tpPoints[0].Set(pTpLT);
1497 tpPoints[1].Set(pTpRT);
1498 tpPoints[2].Set(pTpRB);
1499 tpPoints[3].Set(pTpLB);
1500 }
1501 }
1502
1518 void Set(const TPoint<uint16_t>& tpLT, const TPoint<uint16_t>& tpRT, const TPoint<uint16_t>& tpRB, const TPoint<uint16_t>& tpLB)
1519 {
1520 tpPoints[0].Set(tpLT);
1521 tpPoints[1].Set(tpRT);
1522 tpPoints[2].Set(tpRB);
1523 tpPoints[3].Set(tpLB);
1524 }
1525
1541 void Set(const TPoint<uint16_t>* pTpLT, const TPoint<uint16_t>* pTpRT, const TPoint<uint16_t>* pTpRB, const TPoint<uint16_t>* pTpLB)
1542 {
1543 if(pTpLT && pTpRT && pTpRB && pTpLB)
1544 {
1545 tpPoints[0].Set(pTpLT);
1546 tpPoints[1].Set(pTpRT);
1547 tpPoints[2].Set(pTpRB);
1548 tpPoints[3].Set(pTpLB);
1549 }
1550 }
1551
1567 void Set(const TPoint<int32_t>& tpLT, const TPoint<int32_t>& tpRT, const TPoint<int32_t>& tpRB, const TPoint<int32_t>& tpLB)
1568 {
1569 tpPoints[0].Set(tpLT);
1570 tpPoints[1].Set(tpRT);
1571 tpPoints[2].Set(tpRB);
1572 tpPoints[3].Set(tpLB);
1573 }
1574
1590 void Set(const TPoint<int32_t>* pTpLT, const TPoint<int32_t>* pTpRT, const TPoint<int32_t>* pTpRB, const TPoint<int32_t>* pTpLB)
1591 {
1592 if(pTpLT && pTpRT && pTpRB && pTpLB)
1593 {
1594 tpPoints[0].Set(pTpLT);
1595 tpPoints[1].Set(pTpRT);
1596 tpPoints[2].Set(pTpRB);
1597 tpPoints[3].Set(pTpLB);
1598 }
1599 }
1600
1616 void Set(const TPoint<uint32_t>& tpLT, const TPoint<uint32_t>& tpRT, const TPoint<uint32_t>& tpRB, const TPoint<uint32_t>& tpLB)
1617 {
1618 tpPoints[0].Set(tpLT);
1619 tpPoints[1].Set(tpRT);
1620 tpPoints[2].Set(tpRB);
1621 tpPoints[3].Set(tpLB);
1622 }
1623
1639 void Set(const TPoint<uint32_t>* pTpLT, const TPoint<uint32_t>* pTpRT, const TPoint<uint32_t>* pTpRB, const TPoint<uint32_t>* pTpLB)
1640 {
1641 if(pTpLT && pTpRT && pTpRB && pTpLB)
1642 {
1643 tpPoints[0].Set(pTpLT);
1644 tpPoints[1].Set(pTpRT);
1645 tpPoints[2].Set(pTpRB);
1646 tpPoints[3].Set(pTpLB);
1647 }
1648 }
1649
1665 void Set(const TPoint<int64_t>& tpLT, const TPoint<int64_t>& tpRT, const TPoint<int64_t>& tpRB, const TPoint<int64_t>& tpLB)
1666 {
1667 tpPoints[0].Set(tpLT);
1668 tpPoints[1].Set(tpRT);
1669 tpPoints[2].Set(tpRB);
1670 tpPoints[3].Set(tpLB);
1671 }
1672
1688 void Set(const TPoint<int64_t>* pTpLT, const TPoint<int64_t>* pTpRT, const TPoint<int64_t>* pTpRB, const TPoint<int64_t>* pTpLB)
1689 {
1690 if(pTpLT && pTpRT && pTpRB && pTpLB)
1691 {
1692 tpPoints[0].Set(pTpLT);
1693 tpPoints[1].Set(pTpRT);
1694 tpPoints[2].Set(pTpRB);
1695 tpPoints[3].Set(pTpLB);
1696 }
1697 }
1698
1714 void Set(const TPoint<uint64_t>& tpLT, const TPoint<uint64_t>& tpRT, const TPoint<uint64_t>& tpRB, const TPoint<uint64_t>& tpLB)
1715 {
1716 tpPoints[0].Set(tpLT);
1717 tpPoints[1].Set(tpRT);
1718 tpPoints[2].Set(tpRB);
1719 tpPoints[3].Set(tpLB);
1720 }
1721
1737 void Set(const TPoint<uint64_t>* pTpLT, const TPoint<uint64_t>* pTpRT, const TPoint<uint64_t>* pTpRB, const TPoint<uint64_t>* pTpLB)
1738 {
1739 if(pTpLT && pTpRT && pTpRB && pTpLB)
1740 {
1741 tpPoints[0].Set(pTpLT);
1742 tpPoints[1].Set(pTpRT);
1743 tpPoints[2].Set(pTpRB);
1744 tpPoints[3].Set(pTpLB);
1745 }
1746 }
1747
1763 void Set(const TPoint<float>& tpLT, const TPoint<float>& tpRT, const TPoint<float>& tpRB, const TPoint<float>& tpLB)
1764 {
1765 tpPoints[0].Set(tpLT);
1766 tpPoints[1].Set(tpRT);
1767 tpPoints[2].Set(tpRB);
1768 tpPoints[3].Set(tpLB);
1769 }
1770
1786 void Set(const TPoint<float>* pTpLT, const TPoint<float>* pTpRT, const TPoint<float>* pTpRB, const TPoint<float>* pTpLB)
1787 {
1788 if(pTpLT && pTpRT && pTpRB && pTpLB)
1789 {
1790 tpPoints[0].Set(pTpLT);
1791 tpPoints[1].Set(pTpRT);
1792 tpPoints[2].Set(pTpRB);
1793 tpPoints[3].Set(pTpLB);
1794 }
1795 }
1796
1812 void Set(const TPoint<double>& tpLT, const TPoint<double>& tpRT, const TPoint<double>& tpRB, const TPoint<double>& tpLB)
1813 {
1814 tpPoints[0].Set(tpLT);
1815 tpPoints[1].Set(tpRT);
1816 tpPoints[2].Set(tpRB);
1817 tpPoints[3].Set(tpLB);
1818 }
1819
1835 void Set(const TPoint<double>* pTpLT, const TPoint<double>* pTpRT, const TPoint<double>* pTpRB, const TPoint<double>* pTpLB)
1836 {
1837 if(pTpLT && pTpRT && pTpRB && pTpLB)
1838 {
1839 tpPoints[0].Set(pTpLT);
1840 tpPoints[1].Set(pTpRT);
1841 tpPoints[2].Set(pTpRB);
1842 tpPoints[3].Set(pTpLB);
1843 }
1844 }
1845
1846
1858 const TQuad<T>& operator=(int32_t value)
1859 {
1860 tpPoints[0] = value;
1861 tpPoints[1] = value;
1862 tpPoints[2] = value;
1863 tpPoints[3] = value;
1864
1865 return *this;
1866 }
1867
1879 const TQuad<T>& operator=(int64_t value)
1880 {
1881 tpPoints[0] = value;
1882 tpPoints[1] = value;
1883 tpPoints[2] = value;
1884 tpPoints[3] = value;
1885
1886 return *this;
1887 }
1888
1900 const TQuad<T>& operator=(float value)
1901 {
1902 tpPoints[0] = value;
1903 tpPoints[1] = value;
1904 tpPoints[2] = value;
1905 tpPoints[3] = value;
1906
1907 return *this;
1908 }
1909
1921 const TQuad<T>& operator=(double value)
1922 {
1923 tpPoints[0] = value;
1924 tpPoints[1] = value;
1925 tpPoints[2] = value;
1926 tpPoints[3] = value;
1927
1928 return *this;
1929 }
1930
1942 const TQuad<T>& operator=(const TQuad<int32_t>& tq)
1943 {
1944 Set(tq);
1945
1946 return *this;
1947 }
1948
1960 const TQuad<T>& operator=(const TQuad<int64_t>& tq)
1961 {
1962 Set(tq);
1963
1964 return *this;
1965 }
1966
1978 const TQuad<T>& operator=(const TQuad<float>& tq)
1979 {
1980 Set(tq);
1981
1982 return *this;
1983 }
1984
1996 const TQuad<T>& operator=(const TQuad<double>& tq)
1997 {
1998 Set(tq);
1999
2000 return *this;
2001 }
2002
2014 bool operator==(const TQuad<int32_t>& tq)
2015 {
2016 return tpPoints[0] == tq.tpPoints[0] && tpPoints[1] == tq.tpPoints[1] && tpPoints[2] == tq.tpPoints[2] && tpPoints[3] == tq.tpPoints[3];
2017 }
2018
2030 bool operator==(const TQuad<int64_t>& tq)
2031 {
2032 return tpPoints[0] == tq.tpPoints[0] && tpPoints[1] == tq.tpPoints[1] && tpPoints[2] == tq.tpPoints[2] && tpPoints[3] == tq.tpPoints[3];
2033 }
2034
2046 bool operator==(const TQuad<float>& tq)
2047 {
2048 return tpPoints[0] == tq.tpPoints[0] && tpPoints[1] == tq.tpPoints[1] && tpPoints[2] == tq.tpPoints[2] && tpPoints[3] == tq.tpPoints[3];
2049 }
2050
2062 bool operator==(const TQuad<double>& tq)
2063 {
2064 return tpPoints[0] == tq.tpPoints[0] && tpPoints[1] == tq.tpPoints[1] && tpPoints[2] == tq.tpPoints[2] && tpPoints[3] == tq.tpPoints[3];
2065 }
2066
2078 bool operator!=(const TQuad<int32_t>& tq)
2079 {
2080 return tpPoints[0] != tq.tpPoints[0] || tpPoints[1] != tq.tpPoints[1] || tpPoints[2] != tq.tpPoints[2] || tpPoints[3] != tq.tpPoints[3];
2081 }
2082
2094 bool operator!=(const TQuad<int64_t>& tq)
2095 {
2096 return tpPoints[0] != tq.tpPoints[0] || tpPoints[1] != tq.tpPoints[1] || tpPoints[2] != tq.tpPoints[2] || tpPoints[3] != tq.tpPoints[3];
2097 }
2098
2110 bool operator!=(const TQuad<float>& tq)
2111 {
2112 return tpPoints[0] != tq.tpPoints[0] || tpPoints[1] != tq.tpPoints[1] || tpPoints[2] != tq.tpPoints[2] || tpPoints[3] != tq.tpPoints[3];
2113 }
2114
2126 bool operator!=(const TQuad<double>& tq)
2127 {
2128 return tpPoints[0] != tq.tpPoints[0] || tpPoints[1] != tq.tpPoints[1] || tpPoints[2] != tq.tpPoints[2] || tpPoints[3] != tq.tpPoints[3];
2129 }
2130
2142 const TQuad<T>& operator+=(int32_t value)
2143 {
2144 tpPoints[0] += value;
2145 tpPoints[1] += value;
2146 tpPoints[2] += value;
2147 tpPoints[3] += value;
2148
2149 return *this;
2150 }
2151
2163 const TQuad<T>& operator+=(int64_t value)
2164 {
2165 tpPoints[0] += value;
2166 tpPoints[1] += value;
2167 tpPoints[2] += value;
2168 tpPoints[3] += value;
2169
2170 return *this;
2171 }
2172
2184 const TQuad<T>& operator+=(float value)
2185 {
2186 tpPoints[0] += value;
2187 tpPoints[1] += value;
2188 tpPoints[2] += value;
2189 tpPoints[3] += value;
2190
2191 return *this;
2192 }
2193
2205 const TQuad<T>& operator+=(double value)
2206 {
2207 tpPoints[0] += value;
2208 tpPoints[1] += value;
2209 tpPoints[2] += value;
2210 tpPoints[3] += value;
2211
2212 return *this;
2213 }
2214
2226 const TQuad<T>& operator+=(const TQuad<int32_t>& tq)
2227 {
2228 tpPoints[0] += tq.tpPoints[0];
2229 tpPoints[1] += tq.tpPoints[1];
2230 tpPoints[2] += tq.tpPoints[2];
2231 tpPoints[3] += tq.tpPoints[3];
2232
2233 return *this;
2234 }
2235
2247 const TQuad<T>& operator+=(const TQuad<int64_t>& tq)
2248 {
2249 tpPoints[0] += tq.tpPoints[0];
2250 tpPoints[1] += tq.tpPoints[1];
2251 tpPoints[2] += tq.tpPoints[2];
2252 tpPoints[3] += tq.tpPoints[3];
2253
2254 return *this;
2255 }
2256
2268 const TQuad<T>& operator+=(const TQuad<float>& tq)
2269 {
2270 tpPoints[0] += tq.tpPoints[0];
2271 tpPoints[1] += tq.tpPoints[1];
2272 tpPoints[2] += tq.tpPoints[2];
2273 tpPoints[3] += tq.tpPoints[3];
2274
2275 return *this;
2276 }
2277
2289 const TQuad<T>& operator+=(const TQuad<double>& tq)
2290 {
2291 tpPoints[0] += tq.tpPoints[0];
2292 tpPoints[1] += tq.tpPoints[1];
2293 tpPoints[2] += tq.tpPoints[2];
2294 tpPoints[3] += tq.tpPoints[3];
2295
2296 return *this;
2297 }
2298
2310 const TQuad<T>& operator-=(int32_t value)
2311 {
2312 tpPoints[0] -= value;
2313 tpPoints[1] -= value;
2314 tpPoints[2] -= value;
2315 tpPoints[3] -= value;
2316
2317 return *this;
2318 }
2319
2331 const TQuad<T>& operator-=(int64_t value)
2332 {
2333 tpPoints[0] -= value;
2334 tpPoints[1] -= value;
2335 tpPoints[2] -= value;
2336 tpPoints[3] -= value;
2337
2338 return *this;
2339 }
2340
2352 const TQuad<T>& operator-=(float value)
2353 {
2354 tpPoints[0] -= value;
2355 tpPoints[1] -= value;
2356 tpPoints[2] -= value;
2357 tpPoints[3] -= value;
2358
2359 return *this;
2360 }
2361
2373 const TQuad<T>& operator-=(double value)
2374 {
2375 tpPoints[0] -= value;
2376 tpPoints[1] -= value;
2377 tpPoints[2] -= value;
2378 tpPoints[3] -= value;
2379
2380 return *this;
2381 }
2382
2394 const TQuad<T>& operator-=(const TQuad<int32_t>& tq)
2395 {
2396 tpPoints[0] -= tq.tpPoints[0];
2397 tpPoints[1] -= tq.tpPoints[1];
2398 tpPoints[2] -= tq.tpPoints[2];
2399 tpPoints[3] -= tq.tpPoints[3];
2400
2401 return *this;
2402 }
2403
2415 const TQuad<T>& operator-=(const TQuad<int64_t>& tq)
2416 {
2417 tpPoints[0] -= tq.tpPoints[0];
2418 tpPoints[1] -= tq.tpPoints[1];
2419 tpPoints[2] -= tq.tpPoints[2];
2420 tpPoints[3] -= tq.tpPoints[3];
2421
2422 return *this;
2423 }
2424
2436 const TQuad<T>& operator-=(const TQuad<float>& tq)
2437 {
2438 tpPoints[0] -= tq.tpPoints[0];
2439 tpPoints[1] -= tq.tpPoints[1];
2440 tpPoints[2] -= tq.tpPoints[2];
2441 tpPoints[3] -= tq.tpPoints[3];
2442
2443 return *this;
2444 }
2445
2457 const TQuad<T>& operator-=(const TQuad<double>& tq)
2458 {
2459 tpPoints[0] -= tq.tpPoints[0];
2460 tpPoints[1] -= tq.tpPoints[1];
2461 tpPoints[2] -= tq.tpPoints[2];
2462 tpPoints[3] -= tq.tpPoints[3];
2463
2464 return *this;
2465 }
2466
2478 const TQuad<T>& operator*=(int32_t value)
2479 {
2480 tpPoints[0] *= value;
2481 tpPoints[1] *= value;
2482 tpPoints[2] *= value;
2483 tpPoints[3] *= value;
2484
2485 return *this;
2486 }
2487
2499 const TQuad<T>& operator*=(int64_t value)
2500 {
2501 tpPoints[0] *= value;
2502 tpPoints[1] *= value;
2503 tpPoints[2] *= value;
2504 tpPoints[3] *= value;
2505
2506 return *this;
2507 }
2508
2520 const TQuad<T>& operator*=(float value)
2521 {
2522 tpPoints[0] *= value;
2523 tpPoints[1] *= value;
2524 tpPoints[2] *= value;
2525 tpPoints[3] *= value;
2526
2527 return *this;
2528 }
2529
2541 const TQuad<T>& operator*=(double value)
2542 {
2543 tpPoints[0] *= value;
2544 tpPoints[1] *= value;
2545 tpPoints[2] *= value;
2546 tpPoints[3] *= value;
2547
2548 return *this;
2549 }
2550
2562 const TQuad<T>& operator*=(const TQuad<int32_t>& tq)
2563 {
2564 tpPoints[0] *= tq.tpPoints[0];
2565 tpPoints[1] *= tq.tpPoints[1];
2566 tpPoints[2] *= tq.tpPoints[2];
2567 tpPoints[3] *= tq.tpPoints[3];
2568
2569 return *this;
2570 }
2571
2583 const TQuad<T>& operator*=(const TQuad<int64_t>& tq)
2584 {
2585 tpPoints[0] *= tq.tpPoints[0];
2586 tpPoints[1] *= tq.tpPoints[1];
2587 tpPoints[2] *= tq.tpPoints[2];
2588 tpPoints[3] *= tq.tpPoints[3];
2589
2590 return *this;
2591 }
2592
2604 const TQuad<T>& operator*=(const TQuad<float>& tq)
2605 {
2606 tpPoints[0] *= tq.tpPoints[0];
2607 tpPoints[1] *= tq.tpPoints[1];
2608 tpPoints[2] *= tq.tpPoints[2];
2609 tpPoints[3] *= tq.tpPoints[3];
2610
2611 return *this;
2612 }
2613
2625 const TQuad<T>& operator*=(const TQuad<double>& tq)
2626 {
2627 tpPoints[0] *= tq.tpPoints[0];
2628 tpPoints[1] *= tq.tpPoints[1];
2629 tpPoints[2] *= tq.tpPoints[2];
2630 tpPoints[3] *= tq.tpPoints[3];
2631
2632 return *this;
2633 }
2634
2646 const TQuad<T>& operator/=(int32_t value)
2647 {
2648 tpPoints[0] /= value;
2649 tpPoints[1] /= value;
2650 tpPoints[2] /= value;
2651 tpPoints[3] /= value;
2652
2653 return *this;
2654 }
2655
2667 const TQuad<T>& operator/=(int64_t value)
2668 {
2669 tpPoints[0] /= value;
2670 tpPoints[1] /= value;
2671 tpPoints[2] /= value;
2672 tpPoints[3] /= value;
2673
2674 return *this;
2675 }
2676
2688 const TQuad<T>& operator/=(float value)
2689 {
2690 tpPoints[0] /= value;
2691 tpPoints[1] /= value;
2692 tpPoints[2] /= value;
2693 tpPoints[3] /= value;
2694
2695 return *this;
2696 }
2697
2709 const TQuad<T>& operator/=(double value)
2710 {
2711 tpPoints[0] /= value;
2712 tpPoints[1] /= value;
2713 tpPoints[2] /= value;
2714 tpPoints[3] /= value;
2715
2716 return *this;
2717 }
2718
2730 const TQuad<T>& operator/=(const TQuad<int32_t>& tq)
2731 {
2732 tpPoints[0] /= tq.tpPoints[0];
2733 tpPoints[1] /= tq.tpPoints[1];
2734 tpPoints[2] /= tq.tpPoints[2];
2735 tpPoints[3] /= tq.tpPoints[3];
2736
2737 return *this;
2738 }
2739
2751 const TQuad<T>& operator/=(const TQuad<int64_t>& tq)
2752 {
2753 tpPoints[0] /= tq.tpPoints[0];
2754 tpPoints[1] /= tq.tpPoints[1];
2755 tpPoints[2] /= tq.tpPoints[2];
2756 tpPoints[3] /= tq.tpPoints[3];
2757
2758 return *this;
2759 }
2760
2772 const TQuad<T>& operator/=(const TQuad<float>& tq)
2773 {
2774 tpPoints[0] /= tq.tpPoints[0];
2775 tpPoints[1] /= tq.tpPoints[1];
2776 tpPoints[2] /= tq.tpPoints[2];
2777 tpPoints[3] /= tq.tpPoints[3];
2778
2779 return *this;
2780 }
2781
2793 const TQuad<T>& operator/=(const TQuad<double>& tq)
2794 {
2795 tpPoints[0] /= tq.tpPoints[0];
2796 tpPoints[1] /= tq.tpPoints[1];
2797 tpPoints[2] /= tq.tpPoints[2];
2798 tpPoints[3] /= tq.tpPoints[3];
2799
2800 return *this;
2801 }
2802
2814 TQuad<T> operator+(int32_t value)
2815 {
2816 TQuad<T> tqReturn(this);
2817 tqReturn += value;
2818 return tqReturn;
2819 }
2820
2832 TQuad<T> operator+(int64_t value)
2833 {
2834 TQuad<T> tqReturn(this);
2835 tqReturn += value;
2836 return tqReturn;
2837 }
2838
2850 TQuad<T> operator+(float value)
2851 {
2852 TQuad<T> tqReturn(this);
2853 tqReturn += value;
2854 return tqReturn;
2855 }
2856
2868 TQuad<T> operator+(double value)
2869 {
2870 TQuad<T> tqReturn(this);
2871 tqReturn += value;
2872 return tqReturn;
2873 }
2874
2886 TQuad<T> operator+(const TQuad<int32_t>& tq)
2887 {
2888 TQuad<T> tqReturn(this);
2889 tqReturn += tq;
2890 return tqReturn;
2891 }
2892
2904 TQuad<T> operator+(const TQuad<int64_t>& tq)
2905 {
2906 TQuad<T> tqReturn(this);
2907 tqReturn += tq;
2908 return tqReturn;
2909 }
2910
2922 TQuad<T> operator+(const TQuad<float>& tq)
2923 {
2924 TQuad<T> tqReturn(this);
2925 tqReturn += tq;
2926 return tqReturn;
2927 }
2928
2940 TQuad<T> operator+(const TQuad<double>& tq)
2941 {
2942 TQuad<T> tqReturn(this);
2943 tqReturn += tq;
2944 return tqReturn;
2945 }
2946
2958 TQuad<T> operator-(int32_t value)
2959 {
2960 TQuad<T> tqReturn(this);
2961 tqReturn -= value;
2962 return tqReturn;
2963 }
2964
2976 TQuad<T> operator-(int64_t value)
2977 {
2978 TQuad<T> tqReturn(this);
2979 tqReturn -= value;
2980 return tqReturn;
2981 }
2982
2994 TQuad<T> operator-(float value)
2995 {
2996 TQuad<T> tqReturn(this);
2997 tqReturn -= value;
2998 return tqReturn;
2999 }
3000
3012 TQuad<T> operator-(double value)
3013 {
3014 TQuad<T> tqReturn(this);
3015 tqReturn -= value;
3016 return tqReturn;
3017 }
3018
3030 TQuad<T> operator-(const TQuad<int32_t>& tq)
3031 {
3032 TQuad<T> tqReturn(this);
3033 tqReturn -= tq;
3034 return tqReturn;
3035 }
3036
3048 TQuad<T> operator-(const TQuad<int64_t>& tq)
3049 {
3050 TQuad<T> tqReturn(this);
3051 tqReturn -= tq;
3052 return tqReturn;
3053 }
3054
3066 TQuad<T> operator-(const TQuad<float>& tq)
3067 {
3068 TQuad<T> tqReturn(this);
3069 tqReturn -= tq;
3070 return tqReturn;
3071 }
3072
3084 TQuad<T> operator-(const TQuad<double>& tq)
3085 {
3086 TQuad<T> tqReturn(this);
3087 tqReturn -= tq;
3088 return tqReturn;
3089 }
3090
3102 TQuad<T> operator*(int32_t value)
3103 {
3104 TQuad<T> tqReturn(this);
3105 tqReturn *= value;
3106 return tqReturn;
3107 }
3108
3120 TQuad<T> operator*(int64_t value)
3121 {
3122 TQuad<T> tqReturn(this);
3123 tqReturn *= value;
3124 return tqReturn;
3125 }
3126
3138 TQuad<T> operator*(float value)
3139 {
3140 TQuad<T> tqReturn(this);
3141 tqReturn *= value;
3142 return tqReturn;
3143 }
3144
3156 TQuad<T> operator*(double value)
3157 {
3158 TQuad<T> tqReturn(this);
3159 tqReturn *= value;
3160 return tqReturn;
3161 }
3162
3174 TQuad<T> operator*(const TQuad<int32_t>& tq)
3175 {
3176 TQuad<T> tqReturn(this);
3177 tqReturn *= tq;
3178 return tqReturn;
3179 }
3180
3192 TQuad<T> operator*(const TQuad<int64_t>& tq)
3193 {
3194 TQuad<T> tqReturn(this);
3195 tqReturn *= tq;
3196 return tqReturn;
3197 }
3198
3210 TQuad<T> operator*(const TQuad<float>& tq)
3211 {
3212 TQuad<T> tqReturn(this);
3213 tqReturn *= tq;
3214 return tqReturn;
3215 }
3216
3228 TQuad<T> operator*(const TQuad<double>& tq)
3229 {
3230 TQuad<T> tqReturn(this);
3231 tqReturn *= tq;
3232 return tqReturn;
3233 }
3234
3246 TQuad<T> operator/(int32_t value)
3247 {
3248 TQuad<T> tqReturn(this);
3249 tqReturn /= value;
3250 return tqReturn;
3251 }
3252
3264 TQuad<T> operator/(int64_t value)
3265 {
3266 TQuad<T> tqReturn(this);
3267 tqReturn /= value;
3268 return tqReturn;
3269 }
3270
3282 TQuad<T> operator/(float value)
3283 {
3284 TQuad<T> tqReturn(this);
3285 tqReturn /= value;
3286 return tqReturn;
3287 }
3288
3300 TQuad<T> operator/(double value)
3301 {
3302 TQuad<T> tqReturn(this);
3303 tqReturn /= value;
3304 return tqReturn;
3305 }
3306
3318 TQuad<T> operator/(const TQuad<int32_t>& tq)
3319 {
3320 TQuad<T> tqReturn(this);
3321 tqReturn /= tq;
3322 return tqReturn;
3323 }
3324
3336 TQuad<T> operator/(const TQuad<int64_t>& tq)
3337 {
3338 TQuad<T> tqReturn(this);
3339 tqReturn /= tq;
3340 return tqReturn;
3341 }
3342
3354 TQuad<T> operator/(const TQuad<float>& tq)
3355 {
3356 TQuad<T> tqReturn(this);
3357 tqReturn /= tq;
3358 return tqReturn;
3359 }
3360
3372 TQuad<T> operator/(const TQuad<double>& tq)
3373 {
3374 TQuad<T> tqReturn(this);
3375 tqReturn /= tq;
3376 return tqReturn;
3377 }
3378
3392 friend TQuad<T> operator+(int32_t value, const TQuad<T>& tq)
3393 {
3394 return TQuad<T>(TQuad<double>(tq) + value);
3395 }
3396
3410 friend TQuad<T> operator+(int64_t value, const TQuad<T>& tq)
3411 {
3412 return TQuad<T>(TQuad<double>(tq) + value);
3413 }
3414
3428 friend TQuad<T> operator+(float value, const TQuad<T>& tq)
3429 {
3430 return TQuad<T>(TQuad<double>(tq) + value);
3431 }
3432
3446 friend TQuad<T> operator+(double value, const TQuad<T>& tq)
3447 {
3448 return TQuad<T>(TQuad<double>(tq) + value);
3449 }
3450
3464 friend TQuad<T> operator-(int32_t value, const TQuad<T>& tq)
3465 {
3466 return TQuad<T>(TPoint<T>((T)(value - tq.tpPoints[0].x), (T)(value - tq.tpPoints[0].y)), TPoint<T>((T)(value - tq.tpPoints[1].x), (T)(value - tq.tpPoints[1].y)), TPoint<T>((T)(value - tq.tpPoints[2].x), (T)(value - tq.tpPoints[2].y)), TPoint<T>((T)(value - tq.tpPoints[3].x), (T)(value - tq.tpPoints[3].y)));
3467 }
3468
3482 friend TQuad<T> operator-(int64_t value, const TQuad<T>& tq)
3483 {
3484 return TQuad<T>(TPoint<T>((T)(value - tq.tpPoints[0].x), (T)(value - tq.tpPoints[0].y)), TPoint<T>((T)(value - tq.tpPoints[1].x), (T)(value - tq.tpPoints[1].y)), TPoint<T>((T)(value - tq.tpPoints[2].x), (T)(value - tq.tpPoints[2].y)), TPoint<T>((T)(value - tq.tpPoints[3].x), (T)(value - tq.tpPoints[3].y)));
3485 }
3486
3500 friend TQuad<T> operator-(float value, const TQuad<T>& tq)
3501 {
3502 return TQuad<T>(TPoint<T>((T)(value - tq.tpPoints[0].x), (T)(value - tq.tpPoints[0].y)), TPoint<T>((T)(value - tq.tpPoints[1].x), (T)(value - tq.tpPoints[1].y)), TPoint<T>((T)(value - tq.tpPoints[2].x), (T)(value - tq.tpPoints[2].y)), TPoint<T>((T)(value - tq.tpPoints[3].x), (T)(value - tq.tpPoints[3].y)));
3503 }
3504
3518 friend TQuad<T> operator-(double value, const TQuad<T>& tq)
3519 {
3520 return TQuad<T>(TPoint<T>((T)(value - tq.tpPoints[0].x), (T)(value - tq.tpPoints[0].y)), TPoint<T>((T)(value - tq.tpPoints[1].x), (T)(value - tq.tpPoints[1].y)), TPoint<T>((T)(value - tq.tpPoints[2].x), (T)(value - tq.tpPoints[2].y)), TPoint<T>((T)(value - tq.tpPoints[3].x), (T)(value - tq.tpPoints[3].y)));
3521 }
3522
3536 friend TQuad<T> operator*(int32_t value, const TQuad<T>& tq)
3537 {
3538 return TQuad<T>(TQuad<double>(tq) * value);
3539 }
3540
3554 friend TQuad<T> operator*(int64_t value, const TQuad<T>& tq)
3555 {
3556 return TQuad<T>(TQuad<double>(tq) * value);
3557 }
3558
3572 friend TQuad<T> operator*(float value, const TQuad<T>& tq)
3573 {
3574 return TQuad<T>(TQuad<double>(tq) * value);
3575 }
3576
3590 friend TQuad<T> operator*(double value, const TQuad<T>& tq)
3591 {
3592 return TQuad<T>(TQuad<double>(tq) * value);
3593 }
3594
3608 friend TQuad<T> operator/(int32_t value, const TQuad<T>& tq)
3609 {
3610 return TQuad<T>(TPoint<T>((T)(value / tq.tpPoints[0].x), (T)(value / tq.tpPoints[0].y)), TPoint<T>((T)(value / tq.tpPoints[1].x), (T)(value / tq.tpPoints[1].y)), TPoint<T>((T)(value / tq.tpPoints[2].x), (T)(value / tq.tpPoints[2].y)), TPoint<T>((T)(value / tq.tpPoints[3].x), (T)(value / tq.tpPoints[3].y)));
3611 }
3612
3626 friend TQuad<T> operator/(int64_t value, const TQuad<T>& tq)
3627 {
3628 return TQuad<T>(TPoint<T>((T)(value / tq.tpPoints[0].x), (T)(value / tq.tpPoints[0].y)), TPoint<T>((T)(value / tq.tpPoints[1].x), (T)(value / tq.tpPoints[1].y)), TPoint<T>((T)(value / tq.tpPoints[2].x), (T)(value / tq.tpPoints[2].y)), TPoint<T>((T)(value / tq.tpPoints[3].x), (T)(value / tq.tpPoints[3].y)));
3629 }
3630
3644 friend TQuad<T> operator/(float value, const TQuad<T>& tq)
3645 {
3646 return TQuad<T>(TPoint<T>((T)(value / tq.tpPoints[0].x), (T)(value / tq.tpPoints[0].y)), TPoint<T>((T)(value / tq.tpPoints[1].x), (T)(value / tq.tpPoints[1].y)), TPoint<T>((T)(value / tq.tpPoints[2].x), (T)(value / tq.tpPoints[2].y)), TPoint<T>((T)(value / tq.tpPoints[3].x), (T)(value / tq.tpPoints[3].y)));
3647 }
3648
3662 friend TQuad<T> operator/(double value, const TQuad<T>& tq)
3663 {
3664 return TQuad<T>(TPoint<T>((T)(value / tq.tpPoints[0].x), (T)(value / tq.tpPoints[0].y)), TPoint<T>((T)(value / tq.tpPoints[1].x), (T)(value / tq.tpPoints[1].y)), TPoint<T>((T)(value / tq.tpPoints[2].x), (T)(value / tq.tpPoints[2].y)), TPoint<T>((T)(value / tq.tpPoints[3].x), (T)(value / tq.tpPoints[3].y)));
3665 }
3666 };
3667 #pragma pack(pop)
3668
3669 typedef TQuad<int8_t> TQuadC;
3670 typedef TQuad<uint8_t> TQuadUC;
3671 typedef TQuad<int16_t> TQuadS;
3672 typedef TQuad<uint16_t> TQuadUS;
3673 typedef TQuad<int32_t> TQuadL;
3674 typedef TQuad<uint32_t> TQuadUL;
3675 typedef TQuad<int64_t> TQuadLL;
3676 typedef TQuad<uint64_t> TQuadULL;
3677 typedef TQuad<float> TQuadF;
3678 typedef TQuad<double> TQuadD;
3679 }
3680}
FLImaging::Base::TPoint
Simplified class representing a point.
Definition TPoint.h:37
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< int16_t > *pTq)
Copy constructor.
Definition TQuad.h:189
FLImaging::Base::TQuad::operator-
TQuad< T > operator-(const TQuad< float > &tq)
Subtraction operator.
Definition TQuad.h:3066
FLImaging::Base::TQuad::Set
void Set(const TQuad< float > &tq)
Sets the quadrilateral.
Definition TQuad.h:1290
FLImaging::Base::TQuad::operator*
TQuad< T > operator*(int32_t value)
Multiplication operator.
Definition TQuad.h:3102
FLImaging::Base::TQuad::Set
void Set(const TQuad< int64_t > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1233
FLImaging::Base::TQuad::operator+=
const TQuad< T > & operator+=(double value)
Addition assignment operator.
Definition TQuad.h:2205
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< int32_t > &tq)
Copy constructor.
Definition TQuad.h:246
FLImaging::Base::TQuad::Set
void Set(const TQuad< int32_t > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1159
FLImaging::Base::TQuad::operator/
TQuad< T > operator/(const TQuad< double > &tq)
Division operator.
Definition TQuad.h:3372
FLImaging::Base::TQuad::Set
void Set(const TPoint< float > *pTpLT, const TPoint< float > *pTpRT, const TPoint< float > *pTpRB, const TPoint< float > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1786
FLImaging::Base::TQuad::Set
void Set(const TPoint< int8_t > *pTpLT, const TPoint< int8_t > *pTpRT, const TPoint< int8_t > *pTpRB, const TPoint< int8_t > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1394
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< int16_t > *pTpLT, const TPoint< int16_t > *pTpRT, const TPoint< int16_t > *pTpRB, const TPoint< int16_t > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:595
FLImaging::Base::TQuad::operator-=
const TQuad< T > & operator-=(const TQuad< int32_t > &tq)
Subtraction assignment operator.
Definition TQuad.h:2394
FLImaging::Base::TQuad::operator+
TQuad< T > operator+(float value)
Addition operator.
Definition TQuad.h:2850
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< float > &tq)
Copy constructor.
Definition TQuad.h:394
FLImaging::Base::TQuad::operator/
friend TQuad< T > operator/(int32_t value, const TQuad< T > &tq)
Division operator.
Definition TQuad.h:3608
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< float > *pTq)
Copy constructor.
Definition TQuad.h:411
FLImaging::Base::TQuad::Set
void Set(const TPoint< uint32_t > *pTpLT, const TPoint< uint32_t > *pTpRT, const TPoint< uint32_t > *pTpRB, const TPoint< uint32_t > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1639
FLImaging::Base::TQuad::Set
void Set(const TPoint< int64_t > &tpLT, const TPoint< int64_t > &tpRT, const TPoint< int64_t > &tpRB, const TPoint< int64_t > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1665
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< int8_t > &tpLT, const TPoint< int8_t > &tpRT, const TPoint< int8_t > &tpRB, const TPoint< int8_t > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:474
FLImaging::Base::TQuad::Set
void Set(const TPoint< uint64_t > *pTpLT, const TPoint< uint64_t > *pTpRT, const TPoint< uint64_t > *pTpRB, const TPoint< uint64_t > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1737
FLImaging::Base::TQuad::Set
void Set(const TQuad< int8_t > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1011
FLImaging::Base::TQuad::operator/
TQuad< T > operator/(float value)
Division operator.
Definition TQuad.h:3282
FLImaging::Base::TQuad::operator*
TQuad< T > operator*(const TQuad< float > &tq)
Multiplication operator.
Definition TQuad.h:3210
FLImaging::Base::TQuad::Set
void Set(const TQuad< uint64_t > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1270
FLImaging::Base::TQuad::Set
void Set(const TQuad< uint8_t > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1048
FLImaging::Base::TQuad::operator+
TQuad< T > operator+(double value)
Addition operator.
Definition TQuad.h:2868
FLImaging::Base::TQuad::operator/
friend TQuad< T > operator/(int64_t value, const TQuad< T > &tq)
Division operator.
Definition TQuad.h:3626
FLImaging::Base::TQuad::operator+=
const TQuad< T > & operator+=(const TQuad< float > &tq)
Addition assignment operator.
Definition TQuad.h:2268
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< uint64_t > *pTpLT, const TPoint< uint64_t > *pTpRT, const TPoint< uint64_t > *pTpRB, const TPoint< uint64_t > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:840
FLImaging::Base::TQuad::operator*
TQuad< T > operator*(float value)
Multiplication operator.
Definition TQuad.h:3138
FLImaging::Base::TQuad::Set
void Set(const TQuad< int16_t > &tq)
Sets the quadrilateral.
Definition TQuad.h:1068
FLImaging::Base::TQuad::operator+
friend TQuad< T > operator+(int64_t value, const TQuad< T > &tq)
Addition operator.
Definition TQuad.h:3410
FLImaging::Base::TQuad::operator=
const TQuad< T > & operator=(float value)
Assignment operator.
Definition TQuad.h:1900
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< int64_t > &tq)
Copy constructor.
Definition TQuad.h:320
FLImaging::Base::TQuad::operator-
TQuad< T > operator-(const TQuad< double > &tq)
Subtraction operator.
Definition TQuad.h:3084
FLImaging::Base::TQuad::operator-
TQuad< T > operator-(double value)
Subtraction operator.
Definition TQuad.h:3012
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< int64_t > &tpLT, const TPoint< int64_t > &tpRT, const TPoint< int64_t > &tpRB, const TPoint< int64_t > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:768
FLImaging::Base::TQuad::operator-=
const TQuad< T > & operator-=(double value)
Subtraction assignment operator.
Definition TQuad.h:2373
FLImaging::Base::TQuad::Set
void Set(const TQuad< uint16_t > &tq)
Sets the quadrilateral.
Definition TQuad.h:1105
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< uint64_t > &tq)
Copy constructor.
Definition TQuad.h:357
FLImaging::Base::TQuad::Set
void Set(const TQuad< float > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1307
FLImaging::Base::TQuad::operator/
friend TQuad< T > operator/(float value, const TQuad< T > &tq)
Division operator.
Definition TQuad.h:3644
FLImaging::Base::TQuad::operator+
TQuad< T > operator+(int64_t value)
Addition operator.
Definition TQuad.h:2832
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< uint64_t > &tpLT, const TPoint< uint64_t > &tpRT, const TPoint< uint64_t > &tpRB, const TPoint< uint64_t > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:817
FLImaging::Base::TQuad::operator=
const TQuad< T > & operator=(const TQuad< float > &tq)
Assignment operator.
Definition TQuad.h:1978
FLImaging::Base::TQuad::operator+
TQuad< T > operator+(const TQuad< float > &tq)
Addition operator.
Definition TQuad.h:2922
FLImaging::Base::TQuad::operator+=
const TQuad< T > & operator+=(int32_t value)
Addition assignment operator.
Definition TQuad.h:2142
FLImaging::Base::TQuad::Set
void Set(const TPoint< uint8_t > *pTpLT, const TPoint< uint8_t > *pTpRT, const TPoint< uint8_t > *pTpRB, const TPoint< uint8_t > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1443
FLImaging::Base::TQuad< int8_t >::tpPoints
TPoint< int8_t > tpPoints[4]
Definition TQuad.h:40
FLImaging::Base::TQuad::operator-
TQuad< T > operator-(int32_t value)
Subtraction operator.
Definition TQuad.h:2958
FLImaging::Base::TQuad::Set
void Set(const TQuad< uint8_t > &tq)
Sets the quadrilateral.
Definition TQuad.h:1031
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< float > *pTpLT, const TPoint< float > *pTpRT, const TPoint< float > *pTpRB, const TPoint< float > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:889
FLImaging::Base::TQuad::Set
void Set(const TPoint< uint16_t > *pTpLT, const TPoint< uint16_t > *pTpRT, const TPoint< uint16_t > *pTpRB, const TPoint< uint16_t > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1541
FLImaging::Base::TQuad::operator*=
const TQuad< T > & operator*=(float value)
Multiplication assignment operator.
Definition TQuad.h:2520
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< int32_t > *pTpLT, const TPoint< int32_t > *pTpRT, const TPoint< int32_t > *pTpRB, const TPoint< int32_t > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:693
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< uint16_t > *pTpLT, const TPoint< uint16_t > *pTpRT, const TPoint< uint16_t > *pTpRB, const TPoint< uint16_t > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:644
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< double > *pTq)
Copy constructor.
Definition TQuad.h:448
FLImaging::Base::TQuad::operator+
TQuad< T > operator+(const TQuad< int32_t > &tq)
Addition operator.
Definition TQuad.h:2886
FLImaging::Base::TQuad::operator+=
const TQuad< T > & operator+=(const TQuad< int32_t > &tq)
Addition assignment operator.
Definition TQuad.h:2226
FLImaging::Base::TQuad::operator-
TQuad< T > operator-(float value)
Subtraction operator.
Definition TQuad.h:2994
FLImaging::Base::TQuad::operator*=
const TQuad< T > & operator*=(const TQuad< float > &tq)
Multiplication assignment operator.
Definition TQuad.h:2604
FLImaging::Base::TQuad::operator*
friend TQuad< T > operator*(double value, const TQuad< T > &tq)
Multiplication operator.
Definition TQuad.h:3590
FLImaging::Base::TQuad::Set
void Set(const TQuad< int16_t > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1085
FLImaging::Base::TQuad::operator/=
const TQuad< T > & operator/=(const TQuad< int64_t > &tq)
Division assignment operator.
Definition TQuad.h:2751
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< double > &tpLT, const TPoint< double > &tpRT, const TPoint< double > &tpRB, const TPoint< double > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:915
FLImaging::Base::TQuad::operator*
TQuad< T > operator*(const TQuad< int64_t > &tq)
Multiplication operator.
Definition TQuad.h:3192
FLImaging::Base::TQuad::operator/
TQuad< T > operator/(const TQuad< int32_t > &tq)
Division operator.
Definition TQuad.h:3318
FLImaging::Base::TQuad::operator!=
bool operator!=(const TQuad< int64_t > &tq)
Inequality operator.
Definition TQuad.h:2094
FLImaging::Base::TQuad::operator!=
bool operator!=(const TQuad< double > &tq)
Inequality operator.
Definition TQuad.h:2126
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< uint8_t > &tq)
Copy constructor.
Definition TQuad.h:135
FLImaging::Base::TQuad::operator/=
const TQuad< T > & operator/=(int32_t value)
Division assignment operator.
Definition TQuad.h:2646
FLImaging::Base::TQuad::operator==
bool operator==(const TQuad< int32_t > &tq)
Equality operator.
Definition TQuad.h:2014
FLImaging::Base::TQuad::Set
void Set(const TPoint< double > &tpLT, const TPoint< double > &tpRT, const TPoint< double > &tpRB, const TPoint< double > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1812
FLImaging::Base::TQuad::Set
void Set(const TQuad< uint32_t > &tq)
Sets the quadrilateral.
Definition TQuad.h:1179
FLImaging::Base::TQuad::operator*
TQuad< T > operator*(int64_t value)
Multiplication operator.
Definition TQuad.h:3120
FLImaging::Base::TQuad::operator/=
const TQuad< T > & operator/=(const TQuad< double > &tq)
Division assignment operator.
Definition TQuad.h:2793
FLImaging::Base::TQuad::operator==
bool operator==(const TQuad< float > &tq)
Equality operator.
Definition TQuad.h:2046
FLImaging::Base::TQuad::operator=
const TQuad< T > & operator=(int32_t value)
Assignment operator.
Definition TQuad.h:1858
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< uint32_t > *pTpLT, const TPoint< uint32_t > *pTpRT, const TPoint< uint32_t > *pTpRB, const TPoint< uint32_t > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:742
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< int32_t > &tpLT, const TPoint< int32_t > &tpRT, const TPoint< int32_t > &tpRB, const TPoint< int32_t > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:670
FLImaging::Base::TQuad::operator=
const TQuad< T > & operator=(const TQuad< int32_t > &tq)
Assignment operator.
Definition TQuad.h:1942
FLImaging::Base::TQuad::Set
void Set(const TPoint< int16_t > &tpLT, const TPoint< int16_t > &tpRT, const TPoint< int16_t > &tpRB, const TPoint< int16_t > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1469
FLImaging::Base::TQuad::Set
void Set(const TPoint< int32_t > &tpLT, const TPoint< int32_t > &tpRT, const TPoint< int32_t > &tpRB, const TPoint< int32_t > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1567
FLImaging::Base::TQuad::operator*
friend TQuad< T > operator*(int64_t value, const TQuad< T > &tq)
Multiplication operator.
Definition TQuad.h:3554
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< uint8_t > &tpLT, const TPoint< uint8_t > &tpRT, const TPoint< uint8_t > &tpRB, const TPoint< uint8_t > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:523
FLImaging::Base::TQuad::operator*
friend TQuad< T > operator*(float value, const TQuad< T > &tq)
Multiplication operator.
Definition TQuad.h:3572
FLImaging::Base::TQuad::operator-
TQuad< T > operator-(const TQuad< int32_t > &tq)
Subtraction operator.
Definition TQuad.h:3030
FLImaging::Base::TQuad::Set
void Set(const TQuad< double > &tq)
Sets the quadrilateral.
Definition TQuad.h:1327
FLImaging::Base::TQuad::operator+
TQuad< T > operator+(int32_t value)
Addition operator.
Definition TQuad.h:2814
FLImaging::Base::TQuad::operator-=
const TQuad< T > & operator-=(const TQuad< double > &tq)
Subtraction assignment operator.
Definition TQuad.h:2457
FLImaging::Base::TQuad::operator-=
const TQuad< T > & operator-=(const TQuad< int64_t > &tq)
Subtraction assignment operator.
Definition TQuad.h:2415
FLImaging::Base::TQuad::Set
void Set(const TPoint< uint32_t > &tpLT, const TPoint< uint32_t > &tpRT, const TPoint< uint32_t > &tpRB, const TPoint< uint32_t > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1616
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< double > &tq)
Copy constructor.
Definition TQuad.h:431
FLImaging::Base::TQuad::operator-
TQuad< T > operator-(int64_t value)
Subtraction operator.
Definition TQuad.h:2976
FLImaging::Base::TQuad::operator==
bool operator==(const TQuad< int64_t > &tq)
Equality operator.
Definition TQuad.h:2030
FLImaging::Base::TQuad::TQuad
TQuad(T tLTX, T tLTY, T tRTX, T tRTY, T tRBX, T tRBY, T tLBX, T tLBY)
Constructs a quadrilateral using four corner coordinates.
Definition TQuad.h:77
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< int16_t > &tq)
Copy constructor.
Definition TQuad.h:172
FLImaging::Base::TQuad::Set
void Set(const TPoint< double > *pTpLT, const TPoint< double > *pTpRT, const TPoint< double > *pTpRB, const TPoint< double > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1835
FLImaging::Base::TQuad::operator*=
const TQuad< T > & operator*=(const TQuad< int64_t > &tq)
Multiplication assignment operator.
Definition TQuad.h:2583
FLImaging::Base::TQuad::operator+
TQuad< T > operator+(const TQuad< int64_t > &tq)
Addition operator.
Definition TQuad.h:2904
FLImaging::Base::TQuad::operator+
friend TQuad< T > operator+(int32_t value, const TQuad< T > &tq)
Addition operator.
Definition TQuad.h:3392
FLImaging::Base::TQuad::operator*
friend TQuad< T > operator*(int32_t value, const TQuad< T > &tq)
Multiplication operator.
Definition TQuad.h:3536
FLImaging::Base::TQuad::operator+=
const TQuad< T > & operator+=(const TQuad< int64_t > &tq)
Addition assignment operator.
Definition TQuad.h:2247
FLImaging::Base::TQuad::operator-
friend TQuad< T > operator-(int32_t value, const TQuad< T > &tq)
Subtraction operator.
Definition TQuad.h:3464
FLImaging::Base::TQuad::operator+=
const TQuad< T > & operator+=(const TQuad< double > &tq)
Addition assignment operator.
Definition TQuad.h:2289
FLImaging::Base::TQuad::operator!=
bool operator!=(const TQuad< int32_t > &tq)
Inequality operator.
Definition TQuad.h:2078
FLImaging::Base::TQuad::operator+=
const TQuad< T > & operator+=(float value)
Addition assignment operator.
Definition TQuad.h:2184
FLImaging::Base::TQuad::operator/=
const TQuad< T > & operator/=(const TQuad< int32_t > &tq)
Division assignment operator.
Definition TQuad.h:2730
FLImaging::Base::TQuad::operator/=
const TQuad< T > & operator/=(const TQuad< float > &tq)
Division assignment operator.
Definition TQuad.h:2772
FLImaging::Base::TQuad::Set
void Set(const TQuad< int64_t > &tq)
Sets the quadrilateral.
Definition TQuad.h:1216
FLImaging::Base::TQuad::Set
void Set(const TQuad< uint16_t > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1122
FLImaging::Base::TQuad::Set
void Set(const TPoint< uint64_t > &tpLT, const TPoint< uint64_t > &tpRT, const TPoint< uint64_t > &tpRB, const TPoint< uint64_t > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1714
FLImaging::Base::TQuad::operator==
bool operator==(const TQuad< double > &tq)
Equality operator.
Definition TQuad.h:2062
FLImaging::Base::TQuad::Set
void Set(const TQuad< double > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1344
FLImaging::Base::TQuad::operator!=
bool operator!=(const TQuad< float > &tq)
Inequality operator.
Definition TQuad.h:2110
FLImaging::Base::TQuad::Set
void Set(const TPoint< uint16_t > &tpLT, const TPoint< uint16_t > &tpRT, const TPoint< uint16_t > &tpRB, const TPoint< uint16_t > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1518
FLImaging::Base::TQuad::operator-=
const TQuad< T > & operator-=(int64_t value)
Subtraction assignment operator.
Definition TQuad.h:2331
FLImaging::Base::TQuad::operator*=
const TQuad< T > & operator*=(const TQuad< int32_t > &tq)
Multiplication assignment operator.
Definition TQuad.h:2562
FLImaging::Base::TQuad::Set
void Set(const TQuad< uint32_t > *pTq)
Sets the quadrilateral.
Definition TQuad.h:1196
FLImaging::Base::TQuad::Set
void Set(const TQuad< int8_t > &tq)
Sets the quadrilateral.
Definition TQuad.h:994
FLImaging::Base::TQuad::operator*
TQuad< T > operator*(double value)
Multiplication operator.
Definition TQuad.h:3156
FLImaging::Base::TQuad::Set
void Set(const TPoint< int64_t > *pTpLT, const TPoint< int64_t > *pTpRT, const TPoint< int64_t > *pTpRB, const TPoint< int64_t > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1688
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< int8_t > *pTq)
Copy constructor.
Definition TQuad.h:115
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< int16_t > &tpLT, const TPoint< int16_t > &tpRT, const TPoint< int16_t > &tpRB, const TPoint< int16_t > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:572
FLImaging::Base::TQuad::Set
void Set(const TPoint< float > &tpLT, const TPoint< float > &tpRT, const TPoint< float > &tpRB, const TPoint< float > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1763
FLImaging::Base::TQuad::Set
void Set(const TPoint< int16_t > *pTpLT, const TPoint< int16_t > *pTpRT, const TPoint< int16_t > *pTpRB, const TPoint< int16_t > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1492
FLImaging::Base::TQuad::operator-=
const TQuad< T > & operator-=(int32_t value)
Subtraction assignment operator.
Definition TQuad.h:2310
FLImaging::Base::TQuad::operator/
TQuad< T > operator/(const TQuad< int64_t > &tq)
Division operator.
Definition TQuad.h:3336
FLImaging::Base::TQuad::Set
void Set(const TPoint< int8_t > &tpLT, const TPoint< int8_t > &tpRT, const TPoint< int8_t > &tpRB, const TPoint< int8_t > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1371
FLImaging::Base::TQuad::operator/
TQuad< T > operator/(double value)
Division operator.
Definition TQuad.h:3300
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< uint16_t > &tpLT, const TPoint< uint16_t > &tpRT, const TPoint< uint16_t > &tpRB, const TPoint< uint16_t > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:621
FLImaging::Base::TQuad::Set
void Set(T tLTX, T tLTY, T tRTX, T tRTY, T tRBX, T tRBY, T tLBX, T tLBY)
Sets the quadrilateral using four corner coordinates.
Definition TQuad.h:973
FLImaging::Base::TQuad::operator-=
const TQuad< T > & operator-=(const TQuad< float > &tq)
Subtraction assignment operator.
Definition TQuad.h:2436
FLImaging::Base::TQuad::operator*
TQuad< T > operator*(const TQuad< double > &tq)
Multiplication operator.
Definition TQuad.h:3228
FLImaging::Base::TQuad::Set
void Set(const TQuad< uint64_t > &tq)
Sets the quadrilateral.
Definition TQuad.h:1253
FLImaging::Base::TQuad::operator*=
const TQuad< T > & operator*=(int32_t value)
Multiplication assignment operator.
Definition TQuad.h:2478
FLImaging::Base::TQuad::operator+
TQuad< T > operator+(const TQuad< double > &tq)
Addition operator.
Definition TQuad.h:2940
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< uint32_t > *pTq)
Copy constructor.
Definition TQuad.h:300
FLImaging::Base::TQuad::operator+=
const TQuad< T > & operator+=(int64_t value)
Addition assignment operator.
Definition TQuad.h:2163
FLImaging::Base::TQuad::operator/=
const TQuad< T > & operator/=(float value)
Division assignment operator.
Definition TQuad.h:2688
FLImaging::Base::TQuad::TQuad
TQuad()
Default constructor.
Definition TQuad.h:50
FLImaging::Base::TQuad::Set
void Set(const TQuad< int32_t > &tq)
Sets the quadrilateral.
Definition TQuad.h:1142
FLImaging::Base::TQuad::operator*=
const TQuad< T > & operator*=(double value)
Multiplication assignment operator.
Definition TQuad.h:2541
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< uint8_t > *pTq)
Copy constructor.
Definition TQuad.h:152
FLImaging::Base::TQuad::operator-
friend TQuad< T > operator-(int64_t value, const TQuad< T > &tq)
Subtraction operator.
Definition TQuad.h:3482
FLImaging::Base::TQuad::operator*=
const TQuad< T > & operator*=(const TQuad< double > &tq)
Multiplication assignment operator.
Definition TQuad.h:2625
FLImaging::Base::TQuad::operator-
TQuad< T > operator-(const TQuad< int64_t > &tq)
Subtraction operator.
Definition TQuad.h:3048
FLImaging::Base::TQuad::Set
void Set(const TPoint< uint8_t > &tpLT, const TPoint< uint8_t > &tpRT, const TPoint< uint8_t > &tpRB, const TPoint< uint8_t > &tpLB)
Sets the quadrilateral using four corner points.
Definition TQuad.h:1420
FLImaging::Base::TQuad::operator/
TQuad< T > operator/(int32_t value)
Division operator.
Definition TQuad.h:3246
FLImaging::Base::TQuad::operator/=
const TQuad< T > & operator/=(int64_t value)
Division assignment operator.
Definition TQuad.h:2667
FLImaging::Base::TQuad::operator=
const TQuad< T > & operator=(int64_t value)
Assignment operator.
Definition TQuad.h:1879
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< uint16_t > *pTq)
Copy constructor.
Definition TQuad.h:226
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< uint32_t > &tpLT, const TPoint< uint32_t > &tpRT, const TPoint< uint32_t > &tpRB, const TPoint< uint32_t > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:719
FLImaging::Base::TQuad::operator-=
const TQuad< T > & operator-=(float value)
Subtraction assignment operator.
Definition TQuad.h:2352
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< int32_t > *pTq)
Copy constructor.
Definition TQuad.h:263
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< int8_t > &tq)
Copy constructor.
Definition TQuad.h:98
FLImaging::Base::TQuad::operator/
TQuad< T > operator/(const TQuad< float > &tq)
Division operator.
Definition TQuad.h:3354
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< uint32_t > &tq)
Copy constructor.
Definition TQuad.h:283
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< uint16_t > &tq)
Copy constructor.
Definition TQuad.h:209
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< uint64_t > *pTq)
Copy constructor.
Definition TQuad.h:374
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< double > *pTpLT, const TPoint< double > *pTpRT, const TPoint< double > *pTpRB, const TPoint< double > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:938
FLImaging::Base::TQuad::operator-
friend TQuad< T > operator-(double value, const TQuad< T > &tq)
Subtraction operator.
Definition TQuad.h:3518
FLImaging::Base::TQuad::operator=
const TQuad< T > & operator=(const TQuad< double > &tq)
Assignment operator.
Definition TQuad.h:1996
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< int64_t > *pTpLT, const TPoint< int64_t > *pTpRT, const TPoint< int64_t > *pTpRB, const TPoint< int64_t > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:791
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< int8_t > *pTpLT, const TPoint< int8_t > *pTpRT, const TPoint< int8_t > *pTpRB, const TPoint< int8_t > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:497
FLImaging::Base::TQuad::Set
void Set(const TPoint< int32_t > *pTpLT, const TPoint< int32_t > *pTpRT, const TPoint< int32_t > *pTpRB, const TPoint< int32_t > *pTpLB)
Sets the quadrilateral using pointers to four corner points.
Definition TQuad.h:1590
FLImaging::Base::TQuad::operator/
TQuad< T > operator/(int64_t value)
Division operator.
Definition TQuad.h:3264
FLImaging::Base::TQuad::operator+
friend TQuad< T > operator+(float value, const TQuad< T > &tq)
Addition operator.
Definition TQuad.h:3428
FLImaging::Base::TQuad::operator+
friend TQuad< T > operator+(double value, const TQuad< T > &tq)
Addition operator.
Definition TQuad.h:3446
FLImaging::Base::TQuad::operator-
friend TQuad< T > operator-(float value, const TQuad< T > &tq)
Subtraction operator.
Definition TQuad.h:3500
FLImaging::Base::TQuad::operator*
TQuad< T > operator*(const TQuad< int32_t > &tq)
Multiplication operator.
Definition TQuad.h:3174
FLImaging::Base::TQuad::TQuad
TQuad(const TQuad< int64_t > *pTq)
Copy constructor.
Definition TQuad.h:337
FLImaging::Base::TQuad::operator/
friend TQuad< T > operator/(double value, const TQuad< T > &tq)
Division operator.
Definition TQuad.h:3662
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< uint8_t > *pTpLT, const TPoint< uint8_t > *pTpRT, const TPoint< uint8_t > *pTpRB, const TPoint< uint8_t > *pTpLB)
Constructs a quadrilateral using pointers to four corner points.
Definition TQuad.h:546
FLImaging::Base::TQuad::operator*=
const TQuad< T > & operator*=(int64_t value)
Multiplication assignment operator.
Definition TQuad.h:2499
FLImaging::Base::TQuad::operator=
const TQuad< T > & operator=(double value)
Assignment operator.
Definition TQuad.h:1921
FLImaging::Base::TQuad::operator/=
const TQuad< T > & operator/=(double value)
Division assignment operator.
Definition TQuad.h:2709
FLImaging::Base::TQuad::operator=
const TQuad< T > & operator=(const TQuad< int64_t > &tq)
Assignment operator.
Definition TQuad.h:1960
FLImaging::Base::TQuad::TQuad
TQuad(const TPoint< float > &tpLT, const TPoint< float > &tpRT, const TPoint< float > &tpRB, const TPoint< float > &tpLB)
Constructs a quadrilateral using four corner points.
Definition TQuad.h:866
FLImaging::Base
Definition AESCryptography.h:18
Generated on for FLImaging by doxygen 1.17.0