FLImaging 7.5.18.3
TLine.h
1#pragma once
2
10
11#include <stdint.h>
12#include <type_traits>
13#include <typeinfo>
14
15#include "FLLibTags.h"
16#include "TPoint.h"
17
19namespace FLImaging
20{
22 namespace Base
23 {
35 #pragma pack(push, 1)
36 template <typename T>
37 class FL_EXPORT TLine
38 {
39 public:
44 TPoint<T> tpPoints[2];
45
53 TLine()
54 {
55 }
56
66 TLine(const TLine<int8_t>& tl)
67 {
68 tpPoints[0].x = (T)tl.tpPoints[0].x;
69 tpPoints[0].y = (T)tl.tpPoints[0].y;
70 tpPoints[1].x = (T)tl.tpPoints[1].x;
71 tpPoints[1].y = (T)tl.tpPoints[1].y;
72 }
73
83 TLine(const TLine<int8_t>* pTl)
84 {
85 if(pTl)
86 {
87 tpPoints[0].x = (T)pTl->tpPoints[0].x;
88 tpPoints[0].y = (T)pTl->tpPoints[0].y;
89 tpPoints[1].x = (T)pTl->tpPoints[1].x;
90 tpPoints[1].y = (T)pTl->tpPoints[1].y;
91 }
92 }
93
103 TLine(const TLine<uint8_t>& tl)
104 {
105 tpPoints[0].x = (T)tl.tpPoints[0].x;
106 tpPoints[0].y = (T)tl.tpPoints[0].y;
107 tpPoints[1].x = (T)tl.tpPoints[1].x;
108 tpPoints[1].y = (T)tl.tpPoints[1].y;
109 }
110
120 TLine(const TLine<uint8_t>* pTl)
121 {
122 if(pTl)
123 {
124 tpPoints[0].x = (T)pTl->tpPoints[0].x;
125 tpPoints[0].y = (T)pTl->tpPoints[0].y;
126 tpPoints[1].x = (T)pTl->tpPoints[1].x;
127 tpPoints[1].y = (T)pTl->tpPoints[1].y;
128 }
129 }
130
140 TLine(const TLine<int16_t>& tl)
141 {
142 tpPoints[0].x = (T)tl.tpPoints[0].x;
143 tpPoints[0].y = (T)tl.tpPoints[0].y;
144 tpPoints[1].x = (T)tl.tpPoints[1].x;
145 tpPoints[1].y = (T)tl.tpPoints[1].y;
146 }
147
157 TLine(const TLine<int16_t>* pTl)
158 {
159 if(pTl)
160 {
161 tpPoints[0].x = (T)pTl->tpPoints[0].x;
162 tpPoints[0].y = (T)pTl->tpPoints[0].y;
163 tpPoints[1].x = (T)pTl->tpPoints[1].x;
164 tpPoints[1].y = (T)pTl->tpPoints[1].y;
165 }
166 }
167
177 TLine(const TLine<uint16_t>& tl)
178 {
179 tpPoints[0].x = (T)tl.tpPoints[0].x;
180 tpPoints[0].y = (T)tl.tpPoints[0].y;
181 tpPoints[1].x = (T)tl.tpPoints[1].x;
182 tpPoints[1].y = (T)tl.tpPoints[1].y;
183 }
184
194 TLine(const TLine<uint16_t>* pTl)
195 {
196 if(pTl)
197 {
198 tpPoints[0].x = (T)pTl->tpPoints[0].x;
199 tpPoints[0].y = (T)pTl->tpPoints[0].y;
200 tpPoints[1].x = (T)pTl->tpPoints[1].x;
201 tpPoints[1].y = (T)pTl->tpPoints[1].y;
202 }
203 }
204
214 TLine(const TLine<int32_t>& tl)
215 {
216 tpPoints[0].x = (T)tl.tpPoints[0].x;
217 tpPoints[0].y = (T)tl.tpPoints[0].y;
218 tpPoints[1].x = (T)tl.tpPoints[1].x;
219 tpPoints[1].y = (T)tl.tpPoints[1].y;
220 }
221
231 TLine(const TLine<int32_t>* pTl)
232 {
233 if(pTl)
234 {
235 tpPoints[0].x = (T)pTl->tpPoints[0].x;
236 tpPoints[0].y = (T)pTl->tpPoints[0].y;
237 tpPoints[1].x = (T)pTl->tpPoints[1].x;
238 tpPoints[1].y = (T)pTl->tpPoints[1].y;
239 }
240 }
241
251 TLine(const TLine<uint32_t>& tl)
252 {
253 tpPoints[0].x = (T)tl.tpPoints[0].x;
254 tpPoints[0].y = (T)tl.tpPoints[0].y;
255 tpPoints[1].x = (T)tl.tpPoints[1].x;
256 tpPoints[1].y = (T)tl.tpPoints[1].y;
257 }
258
268 TLine(const TLine<uint32_t>* pTl)
269 {
270 if(pTl)
271 {
272 tpPoints[0].x = (T)pTl->tpPoints[0].x;
273 tpPoints[0].y = (T)pTl->tpPoints[0].y;
274 tpPoints[1].x = (T)pTl->tpPoints[1].x;
275 tpPoints[1].y = (T)pTl->tpPoints[1].y;
276 }
277 }
278
288 TLine(const TLine<int64_t>& tl)
289 {
290 tpPoints[0].x = (T)tl.tpPoints[0].x;
291 tpPoints[0].y = (T)tl.tpPoints[0].y;
292 tpPoints[1].x = (T)tl.tpPoints[1].x;
293 tpPoints[1].y = (T)tl.tpPoints[1].y;
294 }
295
305 TLine(const TLine<int64_t>* pTl)
306 {
307 if(pTl)
308 {
309 tpPoints[0].x = (T)pTl->tpPoints[0].x;
310 tpPoints[0].y = (T)pTl->tpPoints[0].y;
311 tpPoints[1].x = (T)pTl->tpPoints[1].x;
312 tpPoints[1].y = (T)pTl->tpPoints[1].y;
313 }
314 }
315
325 TLine(const TLine<uint64_t>& tl)
326 {
327 tpPoints[0].x = (T)tl.tpPoints[0].x;
328 tpPoints[0].y = (T)tl.tpPoints[0].y;
329 tpPoints[1].x = (T)tl.tpPoints[1].x;
330 tpPoints[1].y = (T)tl.tpPoints[1].y;
331 }
332
342 TLine(const TLine<uint64_t>* pTl)
343 {
344 if(pTl)
345 {
346 tpPoints[0].x = (T)pTl->tpPoints[0].x;
347 tpPoints[0].y = (T)pTl->tpPoints[0].y;
348 tpPoints[1].x = (T)pTl->tpPoints[1].x;
349 tpPoints[1].y = (T)pTl->tpPoints[1].y;
350 }
351 }
352
362 TLine(const TLine<float>& tl)
363 {
364 tpPoints[0].x = (T)tl.tpPoints[0].x;
365 tpPoints[0].y = (T)tl.tpPoints[0].y;
366 tpPoints[1].x = (T)tl.tpPoints[1].x;
367 tpPoints[1].y = (T)tl.tpPoints[1].y;
368 }
369
379 TLine(const TLine<float>* pTl)
380 {
381 if(pTl)
382 {
383 tpPoints[0].x = (T)pTl->tpPoints[0].x;
384 tpPoints[0].y = (T)pTl->tpPoints[0].y;
385 tpPoints[1].x = (T)pTl->tpPoints[1].x;
386 tpPoints[1].y = (T)pTl->tpPoints[1].y;
387 }
388 }
389
399 TLine(const TLine<double>& tl)
400 {
401 tpPoints[0].x = (T)tl.tpPoints[0].x;
402 tpPoints[0].y = (T)tl.tpPoints[0].y;
403 tpPoints[1].x = (T)tl.tpPoints[1].x;
404 tpPoints[1].y = (T)tl.tpPoints[1].y;
405 }
406
416 TLine(const TLine<double>* pTl)
417 {
418 if(pTl)
419 {
420 tpPoints[0].x = (T)pTl->tpPoints[0].x;
421 tpPoints[0].y = (T)pTl->tpPoints[0].y;
422 tpPoints[1].x = (T)pTl->tpPoints[1].x;
423 tpPoints[1].y = (T)pTl->tpPoints[1].y;
424 }
425 }
426
440 TLine(const TPoint<int8_t>& tp0, const TPoint<int8_t>& tp1)
441 {
442 tpPoints[0].x = (T)tp0.x;
443 tpPoints[0].y = (T)tp0.y;
444 tpPoints[1].x = (T)tp1.x;
445 tpPoints[1].y = (T)tp1.y;
446 }
447
461 TLine(const TPoint<int8_t>* pTp0, const TPoint<int8_t>* pTp1)
462 {
463 if(pTp0)
464 {
465 tpPoints[0].x = (T)pTp0->x;
466 tpPoints[0].y = (T)pTp0->y;
467 }
468
469 if(pTp1)
470 {
471 tpPoints[1].x = (T)pTp1->x;
472 tpPoints[1].y = (T)pTp1->y;
473 }
474 }
475
489 TLine(const TPoint<uint8_t>& tp0, const TPoint<uint8_t>& tp1)
490 {
491 tpPoints[0].x = (T)tp0.x;
492 tpPoints[0].y = (T)tp0.y;
493 tpPoints[1].x = (T)tp1.x;
494 tpPoints[1].y = (T)tp1.y;
495 }
496
510 TLine(const TPoint<uint8_t>* pTp0, const TPoint<uint8_t>* pTp1)
511 {
512 if(pTp0)
513 {
514 tpPoints[0].x = (T)pTp0->x;
515 tpPoints[0].y = (T)pTp0->y;
516 }
517
518 if(pTp1)
519 {
520 tpPoints[1].x = (T)pTp1->x;
521 tpPoints[1].y = (T)pTp1->y;
522 }
523 }
524
538 TLine(const TPoint<int16_t>& tp0, const TPoint<int16_t>& tp1)
539 {
540 tpPoints[0].x = (T)tp0.x;
541 tpPoints[0].y = (T)tp0.y;
542 tpPoints[1].x = (T)tp1.x;
543 tpPoints[1].y = (T)tp1.y;
544 }
545
559 TLine(const TPoint<int16_t>* pTp0, const TPoint<int16_t>* pTp1)
560 {
561 if(pTp0)
562 {
563 tpPoints[0].x = (T)pTp0->x;
564 tpPoints[0].y = (T)pTp0->y;
565 }
566
567 if(pTp1)
568 {
569 tpPoints[1].x = (T)pTp1->x;
570 tpPoints[1].y = (T)pTp1->y;
571 }
572 }
573
587 TLine(const TPoint<uint16_t>& tp0, const TPoint<uint16_t>& tp1)
588 {
589 tpPoints[0].x = (T)tp0.x;
590 tpPoints[0].y = (T)tp0.y;
591 tpPoints[1].x = (T)tp1.x;
592 tpPoints[1].y = (T)tp1.y;
593 }
594
608 TLine(const TPoint<uint16_t>* pTp0, const TPoint<uint16_t>* pTp1)
609 {
610 if(pTp0)
611 {
612 tpPoints[0].x = (T)pTp0->x;
613 tpPoints[0].y = (T)pTp0->y;
614 }
615
616 if(pTp1)
617 {
618 tpPoints[1].x = (T)pTp1->x;
619 tpPoints[1].y = (T)pTp1->y;
620 }
621 }
622
636 TLine(const TPoint<int32_t>& tp0, const TPoint<int32_t>& tp1)
637 {
638 tpPoints[0].x = (T)tp0.x;
639 tpPoints[0].y = (T)tp0.y;
640 tpPoints[1].x = (T)tp1.x;
641 tpPoints[1].y = (T)tp1.y;
642 }
643
657 TLine(const TPoint<int32_t>* pTp0, const TPoint<int32_t>* pTp1)
658 {
659 if(pTp0)
660 {
661 tpPoints[0].x = (T)pTp0->x;
662 tpPoints[0].y = (T)pTp0->y;
663 }
664
665 if(pTp1)
666 {
667 tpPoints[1].x = (T)pTp1->x;
668 tpPoints[1].y = (T)pTp1->y;
669 }
670 }
671
685 TLine(const TPoint<uint32_t>& tp0, const TPoint<uint32_t>& tp1)
686 {
687 tpPoints[0].x = (T)tp0.x;
688 tpPoints[0].y = (T)tp0.y;
689 tpPoints[1].x = (T)tp1.x;
690 tpPoints[1].y = (T)tp1.y;
691 }
692
706 TLine(const TPoint<uint32_t>* pTp0, const TPoint<uint32_t>* pTp1)
707 {
708 if(pTp0)
709 {
710 tpPoints[0].x = (T)pTp0->x;
711 tpPoints[0].y = (T)pTp0->y;
712 }
713
714 if(pTp1)
715 {
716 tpPoints[1].x = (T)pTp1->x;
717 tpPoints[1].y = (T)pTp1->y;
718 }
719 }
720
734 TLine(const TPoint<int64_t>& tp0, const TPoint<int64_t>& tp1)
735 {
736 tpPoints[0].x = (T)tp0.x;
737 tpPoints[0].y = (T)tp0.y;
738 tpPoints[1].x = (T)tp1.x;
739 tpPoints[1].y = (T)tp1.y;
740 }
741
755 TLine(const TPoint<int64_t>* pTp0, const TPoint<int64_t>* pTp1)
756 {
757 if(pTp0)
758 {
759 tpPoints[0].x = (T)pTp0->x;
760 tpPoints[0].y = (T)pTp0->y;
761 }
762
763 if(pTp1)
764 {
765 tpPoints[1].x = (T)pTp1->x;
766 tpPoints[1].y = (T)pTp1->y;
767 }
768 }
769
783 TLine(const TPoint<uint64_t>& tp0, const TPoint<uint64_t>& tp1)
784 {
785 tpPoints[0].x = (T)tp0.x;
786 tpPoints[0].y = (T)tp0.y;
787 tpPoints[1].x = (T)tp1.x;
788 tpPoints[1].y = (T)tp1.y;
789 }
790
804 TLine(const TPoint<uint64_t>* pTp0, const TPoint<uint64_t>* pTp1)
805 {
806 if(pTp0)
807 {
808 tpPoints[0].x = (T)pTp0->x;
809 tpPoints[0].y = (T)pTp0->y;
810 }
811
812 if(pTp1)
813 {
814 tpPoints[1].x = (T)pTp1->x;
815 tpPoints[1].y = (T)pTp1->y;
816 }
817 }
818
832 TLine(const TPoint<float>& tp0, const TPoint<float>& tp1)
833 {
834 tpPoints[0].x = (T)tp0.x;
835 tpPoints[0].y = (T)tp0.y;
836 tpPoints[1].x = (T)tp1.x;
837 tpPoints[1].y = (T)tp1.y;
838 }
839
853 TLine(const TPoint<float>* pTp0, const TPoint<float>* pTp1)
854 {
855 if(pTp0)
856 {
857 tpPoints[0].x = (T)pTp0->x;
858 tpPoints[0].y = (T)pTp0->y;
859 }
860
861 if(pTp1)
862 {
863 tpPoints[1].x = (T)pTp1->x;
864 tpPoints[1].y = (T)pTp1->y;
865 }
866 }
867
881 TLine(const TPoint<double>& tp0, const TPoint<double>& tp1)
882 {
883 tpPoints[0].x = (T)tp0.x;
884 tpPoints[0].y = (T)tp0.y;
885 tpPoints[1].x = (T)tp1.x;
886 tpPoints[1].y = (T)tp1.y;
887 }
888
902 TLine(const TPoint<double>* pTp0, const TPoint<double>* pTp1)
903 {
904 if(pTp0)
905 {
906 tpPoints[0].x = (T)pTp0->x;
907 tpPoints[0].y = (T)pTp0->y;
908 }
909
910 if(pTp1)
911 {
912 tpPoints[1].x = (T)pTp1->x;
913 tpPoints[1].y = (T)pTp1->y;
914 }
915 }
916
932 TLine(int8_t x0, int8_t y0, int8_t x1, int8_t y1)
933 {
934 tpPoints[0].x = (T)x0;
935 tpPoints[0].y = (T)y0;
936 tpPoints[1].x = (T)x1;
937 tpPoints[1].y = (T)y1;
938 }
939
955 TLine(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1)
956 {
957 tpPoints[0].x = (T)x0;
958 tpPoints[0].y = (T)y0;
959 tpPoints[1].x = (T)x1;
960 tpPoints[1].y = (T)y1;
961 }
962
978 TLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1)
979 {
980 tpPoints[0].x = (T)x0;
981 tpPoints[0].y = (T)y0;
982 tpPoints[1].x = (T)x1;
983 tpPoints[1].y = (T)y1;
984 }
985
1001 TLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
1002 {
1003 tpPoints[0].x = (T)x0;
1004 tpPoints[0].y = (T)y0;
1005 tpPoints[1].x = (T)x1;
1006 tpPoints[1].y = (T)y1;
1007 }
1008
1024 TLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
1025 {
1026 tpPoints[0].x = (T)x0;
1027 tpPoints[0].y = (T)y0;
1028 tpPoints[1].x = (T)x1;
1029 tpPoints[1].y = (T)y1;
1030 }
1031
1047 TLine(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1)
1048 {
1049 tpPoints[0].x = (T)x0;
1050 tpPoints[0].y = (T)y0;
1051 tpPoints[1].x = (T)x1;
1052 tpPoints[1].y = (T)y1;
1053 }
1054
1070 TLine(int64_t x0, int64_t y0, int64_t x1, int64_t y1)
1071 {
1072 tpPoints[0].x = (T)x0;
1073 tpPoints[0].y = (T)y0;
1074 tpPoints[1].x = (T)x1;
1075 tpPoints[1].y = (T)y1;
1076 }
1077
1093 TLine(uint64_t x0, uint64_t y0, uint64_t x1, uint64_t y1)
1094 {
1095 tpPoints[0].x = (T)x0;
1096 tpPoints[0].y = (T)y0;
1097 tpPoints[1].x = (T)x1;
1098 tpPoints[1].y = (T)y1;
1099 }
1100
1116 TLine(float x0, float y0, float x1, float y1)
1117 {
1118 tpPoints[0].x = (T)x0;
1119 tpPoints[0].y = (T)y0;
1120 tpPoints[1].x = (T)x1;
1121 tpPoints[1].y = (T)y1;
1122 }
1123
1139 TLine(double x0, double y0, double x1, double y1)
1140 {
1141 tpPoints[0].x = (T)x0;
1142 tpPoints[0].y = (T)y0;
1143 tpPoints[1].x = (T)x1;
1144 tpPoints[1].y = (T)y1;
1145 }
1146
1156 void Set(const TLine<int8_t>& tl)
1157 {
1158 tpPoints[0].x = (T)tl.tpPoints[0].x;
1159 tpPoints[0].y = (T)tl.tpPoints[0].y;
1160 tpPoints[1].x = (T)tl.tpPoints[1].x;
1161 tpPoints[1].y = (T)tl.tpPoints[1].y;
1162 }
1163
1173 void Set(const TLine<int8_t>* pTl)
1174 {
1175 if(pTl)
1176 {
1177 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1178 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1179 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1180 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1181 }
1182 }
1183
1193 void Set(const TLine<uint8_t>& tl)
1194 {
1195 tpPoints[0].x = (T)tl.tpPoints[0].x;
1196 tpPoints[0].y = (T)tl.tpPoints[0].y;
1197 tpPoints[1].x = (T)tl.tpPoints[1].x;
1198 tpPoints[1].y = (T)tl.tpPoints[1].y;
1199 }
1200
1210 void Set(const TLine<uint8_t>* pTl)
1211 {
1212 if(pTl)
1213 {
1214 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1215 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1216 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1217 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1218 }
1219 }
1220
1230 void Set(const TLine<int16_t>& tl)
1231 {
1232 tpPoints[0].x = (T)tl.tpPoints[0].x;
1233 tpPoints[0].y = (T)tl.tpPoints[0].y;
1234 tpPoints[1].x = (T)tl.tpPoints[1].x;
1235 tpPoints[1].y = (T)tl.tpPoints[1].y;
1236 }
1237
1247 void Set(const TLine<int16_t>* pTl)
1248 {
1249 if(pTl)
1250 {
1251 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1252 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1253 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1254 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1255 }
1256 }
1257
1267 void Set(const TLine<uint16_t>& tl)
1268 {
1269 tpPoints[0].x = (T)tl.tpPoints[0].x;
1270 tpPoints[0].y = (T)tl.tpPoints[0].y;
1271 tpPoints[1].x = (T)tl.tpPoints[1].x;
1272 tpPoints[1].y = (T)tl.tpPoints[1].y;
1273 }
1274
1284 void Set(const TLine<uint16_t>* pTl)
1285 {
1286 if(pTl)
1287 {
1288 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1289 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1290 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1291 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1292 }
1293 }
1294
1304 void Set(const TLine<int32_t>& tl)
1305 {
1306 tpPoints[0].x = (T)tl.tpPoints[0].x;
1307 tpPoints[0].y = (T)tl.tpPoints[0].y;
1308 tpPoints[1].x = (T)tl.tpPoints[1].x;
1309 tpPoints[1].y = (T)tl.tpPoints[1].y;
1310 }
1311
1321 void Set(const TLine<int32_t>* pTl)
1322 {
1323 if(pTl)
1324 {
1325 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1326 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1327 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1328 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1329 }
1330 }
1331
1341 void Set(const TLine<uint32_t>& tl)
1342 {
1343 tpPoints[0].x = (T)tl.tpPoints[0].x;
1344 tpPoints[0].y = (T)tl.tpPoints[0].y;
1345 tpPoints[1].x = (T)tl.tpPoints[1].x;
1346 tpPoints[1].y = (T)tl.tpPoints[1].y;
1347 }
1348
1358 void Set(const TLine<uint32_t>* pTl)
1359 {
1360 if(pTl)
1361 {
1362 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1363 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1364 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1365 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1366 }
1367 }
1368
1378 void Set(const TLine<int64_t>& tl)
1379 {
1380 tpPoints[0].x = (T)tl.tpPoints[0].x;
1381 tpPoints[0].y = (T)tl.tpPoints[0].y;
1382 tpPoints[1].x = (T)tl.tpPoints[1].x;
1383 tpPoints[1].y = (T)tl.tpPoints[1].y;
1384 }
1385
1395 void Set(const TLine<int64_t>* pTl)
1396 {
1397 if(pTl)
1398 {
1399 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1400 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1401 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1402 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1403 }
1404 }
1405
1415 void Set(const TLine<uint64_t>& tl)
1416 {
1417 tpPoints[0].x = (T)tl.tpPoints[0].x;
1418 tpPoints[0].y = (T)tl.tpPoints[0].y;
1419 tpPoints[1].x = (T)tl.tpPoints[1].x;
1420 tpPoints[1].y = (T)tl.tpPoints[1].y;
1421 }
1422
1432 void Set(const TLine<uint64_t>* pTl)
1433 {
1434 if(pTl)
1435 {
1436 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1437 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1438 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1439 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1440 }
1441 }
1442
1452 void Set(const TLine<float>& tl)
1453 {
1454 tpPoints[0].x = (T)tl.tpPoints[0].x;
1455 tpPoints[0].y = (T)tl.tpPoints[0].y;
1456 tpPoints[1].x = (T)tl.tpPoints[1].x;
1457 tpPoints[1].y = (T)tl.tpPoints[1].y;
1458 }
1459
1469 void Set(const TLine<float>* pTl)
1470 {
1471 if(pTl)
1472 {
1473 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1474 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1475 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1476 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1477 }
1478 }
1479
1489 void Set(const TLine<double>& tl)
1490 {
1491 tpPoints[0].x = (T)tl.tpPoints[0].x;
1492 tpPoints[0].y = (T)tl.tpPoints[0].y;
1493 tpPoints[1].x = (T)tl.tpPoints[1].x;
1494 tpPoints[1].y = (T)tl.tpPoints[1].y;
1495 }
1496
1506 void Set(const TLine<double>* pTl)
1507 {
1508 if(pTl)
1509 {
1510 tpPoints[0].x = (T)pTl->tpPoints[0].x;
1511 tpPoints[0].y = (T)pTl->tpPoints[0].y;
1512 tpPoints[1].x = (T)pTl->tpPoints[1].x;
1513 tpPoints[1].y = (T)pTl->tpPoints[1].y;
1514 }
1515 }
1516
1530 void Set(const TPoint<int8_t>& tp0, const TPoint<int8_t>& tp1)
1531 {
1532 tpPoints[0].x = (T)tp0.x;
1533 tpPoints[0].y = (T)tp0.y;
1534 tpPoints[1].x = (T)tp1.x;
1535 tpPoints[1].y = (T)tp1.y;
1536 }
1537
1551 void Set(const TPoint<int8_t>* pTp0, const TPoint<int8_t>* pTp1)
1552 {
1553 if(pTp0)
1554 {
1555 tpPoints[0].x = (T)pTp0->x;
1556 tpPoints[0].y = (T)pTp0->y;
1557 }
1558
1559 if(pTp1)
1560 {
1561 tpPoints[1].x = (T)pTp1->x;
1562 tpPoints[1].y = (T)pTp1->y;
1563 }
1564 }
1565
1579 void Set(const TPoint<uint8_t>& tp0, const TPoint<uint8_t>& tp1)
1580 {
1581 tpPoints[0].x = (T)tp0.x;
1582 tpPoints[0].y = (T)tp0.y;
1583 tpPoints[1].x = (T)tp1.x;
1584 tpPoints[1].y = (T)tp1.y;
1585 }
1586
1600 void Set(const TPoint<uint8_t>* pTp0, const TPoint<uint8_t>* pTp1)
1601 {
1602 if(pTp0)
1603 {
1604 tpPoints[0].x = (T)pTp0->x;
1605 tpPoints[0].y = (T)pTp0->y;
1606 }
1607
1608 if(pTp1)
1609 {
1610 tpPoints[1].x = (T)pTp1->x;
1611 tpPoints[1].y = (T)pTp1->y;
1612 }
1613 }
1614
1628 void Set(const TPoint<int16_t>& tp0, const TPoint<int16_t>& tp1)
1629 {
1630 tpPoints[0].x = (T)tp0.x;
1631 tpPoints[0].y = (T)tp0.y;
1632 tpPoints[1].x = (T)tp1.x;
1633 tpPoints[1].y = (T)tp1.y;
1634 }
1635
1649 void Set(const TPoint<int16_t>* pTp0, const TPoint<int16_t>* pTp1)
1650 {
1651 if(pTp0)
1652 {
1653 tpPoints[0].x = (T)pTp0->x;
1654 tpPoints[0].y = (T)pTp0->y;
1655 }
1656
1657 if(pTp1)
1658 {
1659 tpPoints[1].x = (T)pTp1->x;
1660 tpPoints[1].y = (T)pTp1->y;
1661 }
1662 }
1663
1677 void Set(const TPoint<uint16_t>& tp0, const TPoint<uint16_t>& tp1)
1678 {
1679 tpPoints[0].x = (T)tp0.x;
1680 tpPoints[0].y = (T)tp0.y;
1681 tpPoints[1].x = (T)tp1.x;
1682 tpPoints[1].y = (T)tp1.y;
1683 }
1684
1698 void Set(const TPoint<uint16_t>* pTp0, const TPoint<uint16_t>* pTp1)
1699 {
1700 if(pTp0)
1701 {
1702 tpPoints[0].x = (T)pTp0->x;
1703 tpPoints[0].y = (T)pTp0->y;
1704 }
1705
1706 if(pTp1)
1707 {
1708 tpPoints[1].x = (T)pTp1->x;
1709 tpPoints[1].y = (T)pTp1->y;
1710 }
1711 }
1712
1726 void Set(const TPoint<int32_t>& tp0, const TPoint<int32_t>& tp1)
1727 {
1728 tpPoints[0].x = (T)tp0.x;
1729 tpPoints[0].y = (T)tp0.y;
1730 tpPoints[1].x = (T)tp1.x;
1731 tpPoints[1].y = (T)tp1.y;
1732 }
1733
1747 void Set(const TPoint<int32_t>* pTp0, const TPoint<int32_t>* pTp1)
1748 {
1749 if(pTp0)
1750 {
1751 tpPoints[0].x = (T)pTp0->x;
1752 tpPoints[0].y = (T)pTp0->y;
1753 }
1754
1755 if(pTp1)
1756 {
1757 tpPoints[1].x = (T)pTp1->x;
1758 tpPoints[1].y = (T)pTp1->y;
1759 }
1760 }
1761
1775 void Set(const TPoint<uint32_t>& tp0, const TPoint<uint32_t>& tp1)
1776 {
1777 tpPoints[0].x = (T)tp0.x;
1778 tpPoints[0].y = (T)tp0.y;
1779 tpPoints[1].x = (T)tp1.x;
1780 tpPoints[1].y = (T)tp1.y;
1781 }
1782
1796 void Set(const TPoint<uint32_t>* pTp0, const TPoint<uint32_t>* pTp1)
1797 {
1798 if(pTp0)
1799 {
1800 tpPoints[0].x = (T)pTp0->x;
1801 tpPoints[0].y = (T)pTp0->y;
1802 }
1803
1804 if(pTp1)
1805 {
1806 tpPoints[1].x = (T)pTp1->x;
1807 tpPoints[1].y = (T)pTp1->y;
1808 }
1809 }
1810
1824 void Set(const TPoint<int64_t>& tp0, const TPoint<int64_t>& tp1)
1825 {
1826 tpPoints[0].x = (T)tp0.x;
1827 tpPoints[0].y = (T)tp0.y;
1828 tpPoints[1].x = (T)tp1.x;
1829 tpPoints[1].y = (T)tp1.y;
1830 }
1831
1845 void Set(const TPoint<int64_t>* pTp0, const TPoint<int64_t>* pTp1)
1846 {
1847 if(pTp0)
1848 {
1849 tpPoints[0].x = (T)pTp0->x;
1850 tpPoints[0].y = (T)pTp0->y;
1851 }
1852
1853 if(pTp1)
1854 {
1855 tpPoints[1].x = (T)pTp1->x;
1856 tpPoints[1].y = (T)pTp1->y;
1857 }
1858 }
1859
1873 void Set(const TPoint<uint64_t>& tp0, const TPoint<uint64_t>& tp1)
1874 {
1875 tpPoints[0].x = (T)tp0.x;
1876 tpPoints[0].y = (T)tp0.y;
1877 tpPoints[1].x = (T)tp1.x;
1878 tpPoints[1].y = (T)tp1.y;
1879 }
1880
1894 void Set(const TPoint<uint64_t>* pTp0, const TPoint<uint64_t>* pTp1)
1895 {
1896 if(pTp0)
1897 {
1898 tpPoints[0].x = (T)pTp0->x;
1899 tpPoints[0].y = (T)pTp0->y;
1900 }
1901
1902 if(pTp1)
1903 {
1904 tpPoints[1].x = (T)pTp1->x;
1905 tpPoints[1].y = (T)pTp1->y;
1906 }
1907 }
1908
1922 void Set(const TPoint<float>& tp0, const TPoint<float>& tp1)
1923 {
1924 tpPoints[0].x = (T)tp0.x;
1925 tpPoints[0].y = (T)tp0.y;
1926 tpPoints[1].x = (T)tp1.x;
1927 tpPoints[1].y = (T)tp1.y;
1928 }
1929
1943 void Set(const TPoint<float>* pTp0, const TPoint<float>* pTp1)
1944 {
1945 if(pTp0)
1946 {
1947 tpPoints[0].x = (T)pTp0->x;
1948 tpPoints[0].y = (T)pTp0->y;
1949 }
1950
1951 if(pTp1)
1952 {
1953 tpPoints[1].x = (T)pTp1->x;
1954 tpPoints[1].y = (T)pTp1->y;
1955 }
1956 }
1957
1971 void Set(const TPoint<double>& tp0, const TPoint<double>& tp1)
1972 {
1973 tpPoints[0].x = (T)tp0.x;
1974 tpPoints[0].y = (T)tp0.y;
1975 tpPoints[1].x = (T)tp1.x;
1976 tpPoints[1].y = (T)tp1.y;
1977 }
1978
1992 void Set(const TPoint<double>* pTp0, const TPoint<double>* pTp1)
1993 {
1994 if(pTp0)
1995 {
1996 tpPoints[0].x = (T)pTp0->x;
1997 tpPoints[0].y = (T)pTp0->y;
1998 }
1999
2000 if(pTp1)
2001 {
2002 tpPoints[1].x = (T)pTp1->x;
2003 tpPoints[1].y = (T)pTp1->y;
2004 }
2005 }
2006
2022 void Set(int8_t x0, int8_t y0, int8_t x1, int8_t y1)
2023 {
2024 tpPoints[0].x = (T)x0;
2025 tpPoints[0].y = (T)y0;
2026 tpPoints[1].x = (T)x1;
2027 tpPoints[1].y = (T)y1;
2028 }
2029
2045 void Set(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1)
2046 {
2047 tpPoints[0].x = (T)x0;
2048 tpPoints[0].y = (T)y0;
2049 tpPoints[1].x = (T)x1;
2050 tpPoints[1].y = (T)y1;
2051 }
2052
2068 void Set(int16_t x0, int16_t y0, int16_t x1, int16_t y1)
2069 {
2070 tpPoints[0].x = (T)x0;
2071 tpPoints[0].y = (T)y0;
2072 tpPoints[1].x = (T)x1;
2073 tpPoints[1].y = (T)y1;
2074 }
2075
2091 void Set(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
2092 {
2093 tpPoints[0].x = (T)x0;
2094 tpPoints[0].y = (T)y0;
2095 tpPoints[1].x = (T)x1;
2096 tpPoints[1].y = (T)y1;
2097 }
2098
2114 void Set(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
2115 {
2116 tpPoints[0].x = (T)x0;
2117 tpPoints[0].y = (T)y0;
2118 tpPoints[1].x = (T)x1;
2119 tpPoints[1].y = (T)y1;
2120 }
2121
2137 void Set(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1)
2138 {
2139 tpPoints[0].x = (T)x0;
2140 tpPoints[0].y = (T)y0;
2141 tpPoints[1].x = (T)x1;
2142 tpPoints[1].y = (T)y1;
2143 }
2144
2160 void Set(int64_t x0, int64_t y0, int64_t x1, int64_t y1)
2161 {
2162 tpPoints[0].x = (T)x0;
2163 tpPoints[0].y = (T)y0;
2164 tpPoints[1].x = (T)x1;
2165 tpPoints[1].y = (T)y1;
2166 }
2167
2183 void Set(uint64_t x0, uint64_t y0, uint64_t x1, uint64_t y1)
2184 {
2185 tpPoints[0].x = (T)x0;
2186 tpPoints[0].y = (T)y0;
2187 tpPoints[1].x = (T)x1;
2188 tpPoints[1].y = (T)y1;
2189 }
2190
2206 void Set(float x0, float y0, float x1, float y1)
2207 {
2208 tpPoints[0].x = (T)x0;
2209 tpPoints[0].y = (T)y0;
2210 tpPoints[1].x = (T)x1;
2211 tpPoints[1].y = (T)y1;
2212 }
2213
2229 void Set(double x0, double y0, double x1, double y1)
2230 {
2231 tpPoints[0].x = (T)x0;
2232 tpPoints[0].y = (T)y0;
2233 tpPoints[1].x = (T)x1;
2234 tpPoints[1].y = (T)y1;
2235 }
2236
2248 const TLine<T>& operator=(int32_t value)
2249 {
2250 tpPoints[0].x = tpPoints[0].y = tpPoints[1].x = tpPoints[1].y = (T)value;
2251
2252 return *this;
2253 }
2254
2266 const TLine<T>& operator=(int64_t value)
2267 {
2268 tpPoints[0].x = tpPoints[0].y = tpPoints[1].x = tpPoints[1].y = (T)value;
2269
2270 return *this;
2271 }
2272
2284 const TLine<T>& operator=(float value)
2285 {
2286 tpPoints[0].x = tpPoints[0].y = tpPoints[1].x = tpPoints[1].y = (T)value;
2287
2288 return *this;
2289 }
2290
2302 const TLine<T>& operator=(double value)
2303 {
2304 tpPoints[0].x = tpPoints[0].y = tpPoints[1].x = tpPoints[1].y = (T)value;
2305
2306 return *this;
2307 }
2308
2322 const TLine<T>& operator=(const TPoint<int32_t>& tp)
2323 {
2324 tpPoints[0].x = tpPoints[1].x = (T)tp.x;
2325 tpPoints[0].y = tpPoints[1].y = (T)tp.y;
2326
2327 return *this;
2328 }
2329
2343 const TLine<T>& operator=(const TPoint<int64_t>& tp)
2344 {
2345 tpPoints[0].x = tpPoints[1].x = (T)tp.x;
2346 tpPoints[0].y = tpPoints[1].y = (T)tp.y;
2347
2348 return *this;
2349 }
2350
2364 const TLine<T>& operator=(const TPoint<float>& tp)
2365 {
2366 tpPoints[0].x = tpPoints[1].x = (T)tp.x;
2367 tpPoints[0].y = tpPoints[1].y = (T)tp.y;
2368
2369 return *this;
2370 }
2371
2385 const TLine<T>& operator=(const TPoint<double>& tp)
2386 {
2387 tpPoints[0].x = tpPoints[1].x = (T)tp.x;
2388 tpPoints[0].y = tpPoints[1].y = (T)tp.y;
2389
2390 return *this;
2391 }
2392
2404 const TLine<T>& operator=(const TLine<int32_t>& tl)
2405 {
2406 tpPoints[0].x = (T)tl.tpPoints[0].x;
2407 tpPoints[0].y = (T)tl.tpPoints[0].y;
2408 tpPoints[1].x = (T)tl.tpPoints[1].x;
2409 tpPoints[1].y = (T)tl.tpPoints[1].y;
2410
2411 return *this;
2412 }
2413
2425 const TLine<T>& operator=(const TLine<int64_t>& tl)
2426 {
2427 tpPoints[0].x = (T)tl.tpPoints[0].x;
2428 tpPoints[0].y = (T)tl.tpPoints[0].y;
2429 tpPoints[1].x = (T)tl.tpPoints[1].x;
2430 tpPoints[1].y = (T)tl.tpPoints[1].y;
2431
2432 return *this;
2433 }
2434
2446 const TLine<T>& operator=(const TLine<float>& tl)
2447 {
2448 tpPoints[0].x = (T)tl.tpPoints[0].x;
2449 tpPoints[0].y = (T)tl.tpPoints[0].y;
2450 tpPoints[1].x = (T)tl.tpPoints[1].x;
2451 tpPoints[1].y = (T)tl.tpPoints[1].y;
2452
2453 return *this;
2454 }
2455
2467 const TLine<T>& operator=(const TLine<double>& tl)
2468 {
2469 tpPoints[0].x = (T)tl.tpPoints[0].x;
2470 tpPoints[0].y = (T)tl.tpPoints[0].y;
2471 tpPoints[1].x = (T)tl.tpPoints[1].x;
2472 tpPoints[1].y = (T)tl.tpPoints[1].y;
2473
2474 return *this;
2475 }
2476
2488 bool operator==(const TLine<int32_t>& tl) const
2489 {
2490 return tpPoints[0].x == (T)tl.tpPoints[0].x && tpPoints[0].y == (T)tl.tpPoints[0].y && tpPoints[1].x == (T)tl.tpPoints[1].x && tpPoints[1].y == (T)tl.tpPoints[1].y;
2491 }
2492
2504 bool operator==(const TLine<int64_t>& tl) const
2505 {
2506 return tpPoints[0].x == (T)tl.tpPoints[0].x && tpPoints[0].y == (T)tl.tpPoints[0].y && tpPoints[1].x == (T)tl.tpPoints[1].x && tpPoints[1].y == (T)tl.tpPoints[1].y;
2507 }
2508
2520 bool operator==(const TLine<float>& tl) const
2521 {
2522 return tpPoints[0].x == (T)tl.tpPoints[0].x && tpPoints[0].y == (T)tl.tpPoints[0].y && tpPoints[1].x == (T)tl.tpPoints[1].x && tpPoints[1].y == (T)tl.tpPoints[1].y;
2523 }
2524
2536 bool operator==(const TLine<double>& tl) const
2537 {
2538 return tpPoints[0].x == (T)tl.tpPoints[0].x && tpPoints[0].y == (T)tl.tpPoints[0].y && tpPoints[1].x == (T)tl.tpPoints[1].x && tpPoints[1].y == (T)tl.tpPoints[1].y;
2539 }
2540
2552 bool operator!=(const TLine<int32_t>& tl) const
2553 {
2554 return tpPoints[0].x != (T)tl.tpPoints[0].x || tpPoints[0].y != (T)tl.tpPoints[0].y || tpPoints[1].x != (T)tl.tpPoints[1].x || tpPoints[1].y != (T)tl.tpPoints[1].y;
2555 }
2556
2568 bool operator!=(const TLine<int64_t>& tl) const
2569 {
2570 return tpPoints[0].x != (T)tl.tpPoints[0].x || tpPoints[0].y != (T)tl.tpPoints[0].y || tpPoints[1].x != (T)tl.tpPoints[1].x || tpPoints[1].y != (T)tl.tpPoints[1].y;
2571 }
2572
2584 bool operator!=(const TLine<float>& tl) const
2585 {
2586 return tpPoints[0].x != (T)tl.tpPoints[0].x || tpPoints[0].y != (T)tl.tpPoints[0].y || tpPoints[1].x != (T)tl.tpPoints[1].x || tpPoints[1].y != (T)tl.tpPoints[1].y;
2587 }
2588
2600 bool operator!=(const TLine<double>& tl) const
2601 {
2602 return tpPoints[0].x != (T)tl.tpPoints[0].x || tpPoints[0].y != (T)tl.tpPoints[0].y || tpPoints[1].x != (T)tl.tpPoints[1].x || tpPoints[1].y != (T)tl.tpPoints[1].y;
2603 }
2604
2616 const TLine<T>& operator+=(int32_t value)
2617 {
2618 tpPoints[0].x += (T)value;
2619 tpPoints[0].y += (T)value;
2620 tpPoints[1].x += (T)value;
2621 tpPoints[1].y += (T)value;
2622
2623 return *this;
2624 }
2625
2637 const TLine<T>& operator+=(int64_t value)
2638 {
2639 tpPoints[0].x += (T)value;
2640 tpPoints[0].y += (T)value;
2641 tpPoints[1].x += (T)value;
2642 tpPoints[1].y += (T)value;
2643
2644 return *this;
2645 }
2646
2658 const TLine<T>& operator+=(float value)
2659 {
2660 tpPoints[0].x += (T)value;
2661 tpPoints[0].y += (T)value;
2662 tpPoints[1].x += (T)value;
2663 tpPoints[1].y += (T)value;
2664
2665 return *this;
2666 }
2667
2679 const TLine<T>& operator+=(double value)
2680 {
2681 tpPoints[0].x += (T)value;
2682 tpPoints[0].y += (T)value;
2683 tpPoints[1].x += (T)value;
2684 tpPoints[1].y += (T)value;
2685
2686 return *this;
2687 }
2688
2702 const TLine<T>& operator+=(const TPoint<int32_t>& tp)
2703 {
2704 tpPoints[0].x += (T)tp.x;
2705 tpPoints[0].y += (T)tp.y;
2706 tpPoints[1].x += (T)tp.x;
2707 tpPoints[1].y += (T)tp.y;
2708
2709 return *this;
2710 }
2711
2725 const TLine<T>& operator+=(const TPoint<int64_t>& tp)
2726 {
2727 tpPoints[0].x += (T)tp.x;
2728 tpPoints[0].y += (T)tp.y;
2729 tpPoints[1].x += (T)tp.x;
2730 tpPoints[1].y += (T)tp.y;
2731
2732 return *this;
2733 }
2734
2748 const TLine<T>& operator+=(const TPoint<float>& tp)
2749 {
2750 tpPoints[0].x += (T)tp.x;
2751 tpPoints[0].y += (T)tp.y;
2752 tpPoints[1].x += (T)tp.x;
2753 tpPoints[1].y += (T)tp.y;
2754
2755 return *this;
2756 }
2757
2771 const TLine<T>& operator+=(const TPoint<double>& tp)
2772 {
2773 tpPoints[0].x += (T)tp.x;
2774 tpPoints[0].y += (T)tp.y;
2775 tpPoints[1].x += (T)tp.x;
2776 tpPoints[1].y += (T)tp.y;
2777
2778 return *this;
2779 }
2780
2792 const TLine<T>& operator+=(const TLine<int32_t>& tl)
2793 {
2794 tpPoints[0].x += (T)tl.tpPoints[0].x;
2795 tpPoints[0].y += (T)tl.tpPoints[0].y;
2796 tpPoints[1].x += (T)tl.tpPoints[1].x;
2797 tpPoints[1].y += (T)tl.tpPoints[1].y;
2798
2799 return *this;
2800 }
2801
2813 const TLine<T>& operator+=(const TLine<int64_t>& tl)
2814 {
2815 tpPoints[0].x += (T)tl.tpPoints[0].x;
2816 tpPoints[0].y += (T)tl.tpPoints[0].y;
2817 tpPoints[1].x += (T)tl.tpPoints[1].x;
2818 tpPoints[1].y += (T)tl.tpPoints[1].y;
2819
2820 return *this;
2821 }
2822
2834 const TLine<T>& operator+=(const TLine<float>& tl)
2835 {
2836 tpPoints[0].x += (T)tl.tpPoints[0].x;
2837 tpPoints[0].y += (T)tl.tpPoints[0].y;
2838 tpPoints[1].x += (T)tl.tpPoints[1].x;
2839 tpPoints[1].y += (T)tl.tpPoints[1].y;
2840
2841 return *this;
2842 }
2843
2855 const TLine<T>& operator+=(const TLine<double>& tl)
2856 {
2857 tpPoints[0].x += (T)tl.tpPoints[0].x;
2858 tpPoints[0].y += (T)tl.tpPoints[0].y;
2859 tpPoints[1].x += (T)tl.tpPoints[1].x;
2860 tpPoints[1].y += (T)tl.tpPoints[1].y;
2861
2862 return *this;
2863 }
2864
2876 const TLine<T>& operator-=(int32_t value)
2877 {
2878 tpPoints[0].x -= (T)value;
2879 tpPoints[0].y -= (T)value;
2880 tpPoints[1].x -= (T)value;
2881 tpPoints[1].y -= (T)value;
2882
2883 return *this;
2884 }
2885
2897 const TLine<T>& operator-=(int64_t value)
2898 {
2899 tpPoints[0].x -= (T)value;
2900 tpPoints[0].y -= (T)value;
2901 tpPoints[1].x -= (T)value;
2902 tpPoints[1].y -= (T)value;
2903
2904 return *this;
2905 }
2906
2918 const TLine<T>& operator-=(float value)
2919 {
2920 tpPoints[0].x -= (T)value;
2921 tpPoints[0].y -= (T)value;
2922 tpPoints[1].x -= (T)value;
2923 tpPoints[1].y -= (T)value;
2924
2925 return *this;
2926 }
2927
2939 const TLine<T>& operator-=(double value)
2940 {
2941 tpPoints[0].x -= (T)value;
2942 tpPoints[0].y -= (T)value;
2943 tpPoints[1].x -= (T)value;
2944 tpPoints[1].y -= (T)value;
2945
2946 return *this;
2947 }
2948
2962 const TLine<T>& operator-=(const TPoint<int32_t>& tp)
2963 {
2964 tpPoints[0].x -= (T)tp.x;
2965 tpPoints[0].y -= (T)tp.y;
2966 tpPoints[1].x -= (T)tp.x;
2967 tpPoints[1].y -= (T)tp.y;
2968
2969 return *this;
2970 }
2971
2985 const TLine<T>& operator-=(const TPoint<int64_t>& tp)
2986 {
2987 tpPoints[0].x -= (T)tp.x;
2988 tpPoints[0].y -= (T)tp.y;
2989 tpPoints[1].x -= (T)tp.x;
2990 tpPoints[1].y -= (T)tp.y;
2991
2992 return *this;
2993 }
2994
3008 const TLine<T>& operator-=(const TPoint<float>& tp)
3009 {
3010 tpPoints[0].x -= (T)tp.x;
3011 tpPoints[0].y -= (T)tp.y;
3012 tpPoints[1].x -= (T)tp.x;
3013 tpPoints[1].y -= (T)tp.y;
3014
3015 return *this;
3016 }
3017
3031 const TLine<T>& operator-=(const TPoint<double>& tp)
3032 {
3033 tpPoints[0].x -= (T)tp.x;
3034 tpPoints[0].y -= (T)tp.y;
3035 tpPoints[1].x -= (T)tp.x;
3036 tpPoints[1].y -= (T)tp.y;
3037
3038 return *this;
3039 }
3040
3052 const TLine<T>& operator-=(const TLine<int32_t>& tl)
3053 {
3054 tpPoints[0].x -= (T)tl.tpPoints[0].x;
3055 tpPoints[0].y -= (T)tl.tpPoints[0].y;
3056 tpPoints[1].x -= (T)tl.tpPoints[1].x;
3057 tpPoints[1].y -= (T)tl.tpPoints[1].y;
3058
3059 return *this;
3060 }
3061
3073 const TLine<T>& operator-=(const TLine<int64_t>& tl)
3074 {
3075 tpPoints[0].x -= (T)tl.tpPoints[0].x;
3076 tpPoints[0].y -= (T)tl.tpPoints[0].y;
3077 tpPoints[1].x -= (T)tl.tpPoints[1].x;
3078 tpPoints[1].y -= (T)tl.tpPoints[1].y;
3079
3080 return *this;
3081 }
3082
3094 const TLine<T>& operator-=(const TLine<float>& tl)
3095 {
3096 tpPoints[0].x -= (T)tl.tpPoints[0].x;
3097 tpPoints[0].y -= (T)tl.tpPoints[0].y;
3098 tpPoints[1].x -= (T)tl.tpPoints[1].x;
3099 tpPoints[1].y -= (T)tl.tpPoints[1].y;
3100
3101 return *this;
3102 }
3103
3115 const TLine<T>& operator-=(const TLine<double>& tl)
3116 {
3117 tpPoints[0].x -= (T)tl.tpPoints[0].x;
3118 tpPoints[0].y -= (T)tl.tpPoints[0].y;
3119 tpPoints[1].x -= (T)tl.tpPoints[1].x;
3120 tpPoints[1].y -= (T)tl.tpPoints[1].y;
3121
3122 return *this;
3123 }
3124
3136 const TLine<T>& operator*=(int32_t value)
3137 {
3138 tpPoints[0].x *= (T)value;
3139 tpPoints[0].y *= (T)value;
3140 tpPoints[1].x *= (T)value;
3141 tpPoints[1].y *= (T)value;
3142
3143 return *this;
3144 }
3145
3157 const TLine<T>& operator*=(int64_t value)
3158 {
3159 tpPoints[0].x *= (T)value;
3160 tpPoints[0].y *= (T)value;
3161 tpPoints[1].x *= (T)value;
3162 tpPoints[1].y *= (T)value;
3163
3164 return *this;
3165 }
3166
3178 const TLine<T>& operator*=(float value)
3179 {
3180 tpPoints[0].x *= (T)value;
3181 tpPoints[0].y *= (T)value;
3182 tpPoints[1].x *= (T)value;
3183 tpPoints[1].y *= (T)value;
3184
3185 return *this;
3186 }
3187
3199 const TLine<T>& operator*=(double value)
3200 {
3201 tpPoints[0].x *= (T)value;
3202 tpPoints[0].y *= (T)value;
3203 tpPoints[1].x *= (T)value;
3204 tpPoints[1].y *= (T)value;
3205
3206 return *this;
3207 }
3208
3222 const TLine<T>& operator*=(const TPoint<int32_t>& tp)
3223 {
3224 tpPoints[0].x *= (T)tp.x;
3225 tpPoints[0].y *= (T)tp.y;
3226 tpPoints[1].x *= (T)tp.x;
3227 tpPoints[1].y *= (T)tp.y;
3228
3229 return *this;
3230 }
3231
3245 const TLine<T>& operator*=(const TPoint<int64_t>& tp)
3246 {
3247 tpPoints[0].x *= (T)tp.x;
3248 tpPoints[0].y *= (T)tp.y;
3249 tpPoints[1].x *= (T)tp.x;
3250 tpPoints[1].y *= (T)tp.y;
3251
3252 return *this;
3253 }
3254
3268 const TLine<T>& operator*=(const TPoint<float>& tp)
3269 {
3270 tpPoints[0].x *= (T)tp.x;
3271 tpPoints[0].y *= (T)tp.y;
3272 tpPoints[1].x *= (T)tp.x;
3273 tpPoints[1].y *= (T)tp.y;
3274
3275 return *this;
3276 }
3277
3291 const TLine<T>& operator*=(const TPoint<double>& tp)
3292 {
3293 tpPoints[0].x *= (T)tp.x;
3294 tpPoints[0].y *= (T)tp.y;
3295 tpPoints[1].x *= (T)tp.x;
3296 tpPoints[1].y *= (T)tp.y;
3297
3298 return *this;
3299 }
3300
3312 const TLine<T>& operator*=(const TLine<int32_t>& tl)
3313 {
3314 tpPoints[0].x *= (T)tl.tpPoints[0].x;
3315 tpPoints[0].y *= (T)tl.tpPoints[0].y;
3316 tpPoints[1].x *= (T)tl.tpPoints[1].x;
3317 tpPoints[1].y *= (T)tl.tpPoints[1].y;
3318
3319 return *this;
3320 }
3321
3333 const TLine<T>& operator*=(const TLine<int64_t>& tl)
3334 {
3335 tpPoints[0].x *= (T)tl.tpPoints[0].x;
3336 tpPoints[0].y *= (T)tl.tpPoints[0].y;
3337 tpPoints[1].x *= (T)tl.tpPoints[1].x;
3338 tpPoints[1].y *= (T)tl.tpPoints[1].y;
3339
3340 return *this;
3341 }
3342
3354 const TLine<T>& operator*=(const TLine<float>& tl)
3355 {
3356 tpPoints[0].x *= (T)tl.tpPoints[0].x;
3357 tpPoints[0].y *= (T)tl.tpPoints[0].y;
3358 tpPoints[1].x *= (T)tl.tpPoints[1].x;
3359 tpPoints[1].y *= (T)tl.tpPoints[1].y;
3360
3361 return *this;
3362 }
3363
3375 const TLine<T>& operator*=(const TLine<double>& tl)
3376 {
3377 tpPoints[0].x *= (T)tl.tpPoints[0].x;
3378 tpPoints[0].y *= (T)tl.tpPoints[0].y;
3379 tpPoints[1].x *= (T)tl.tpPoints[1].x;
3380 tpPoints[1].y *= (T)tl.tpPoints[1].y;
3381
3382 return *this;
3383 }
3384
3396 const TLine<T>& operator/=(int32_t value)
3397 {
3398 tpPoints[0].x /= (T)value;
3399 tpPoints[0].y /= (T)value;
3400 tpPoints[1].x /= (T)value;
3401 tpPoints[1].y /= (T)value;
3402
3403 return *this;
3404 }
3405
3417 const TLine<T>& operator/=(int64_t value)
3418 {
3419 tpPoints[0].x /= (T)value;
3420 tpPoints[0].y /= (T)value;
3421 tpPoints[1].x /= (T)value;
3422 tpPoints[1].y /= (T)value;
3423
3424 return *this;
3425 }
3426
3438 const TLine<T>& operator/=(float value)
3439 {
3440 tpPoints[0].x /= (T)value;
3441 tpPoints[0].y /= (T)value;
3442 tpPoints[1].x /= (T)value;
3443 tpPoints[1].y /= (T)value;
3444
3445 return *this;
3446 }
3447
3459 const TLine<T>& operator/=(double value)
3460 {
3461 tpPoints[0].x /= (T)value;
3462 tpPoints[0].y /= (T)value;
3463 tpPoints[1].x /= (T)value;
3464 tpPoints[1].y /= (T)value;
3465
3466 return *this;
3467 }
3468
3482 const TLine<T>& operator/=(const TPoint<int32_t>& tp)
3483 {
3484 tpPoints[0].x /= (T)tp.x;
3485 tpPoints[0].y /= (T)tp.y;
3486 tpPoints[1].x /= (T)tp.x;
3487 tpPoints[1].y /= (T)tp.y;
3488
3489 return *this;
3490 }
3491
3505 const TLine<T>& operator/=(const TPoint<int64_t>& tp)
3506 {
3507 tpPoints[0].x /= (T)tp.x;
3508 tpPoints[0].y /= (T)tp.y;
3509 tpPoints[1].x /= (T)tp.x;
3510 tpPoints[1].y /= (T)tp.y;
3511
3512 return *this;
3513 }
3514
3528 const TLine<T>& operator/=(const TPoint<float>& tp)
3529 {
3530 tpPoints[0].x /= (T)tp.x;
3531 tpPoints[0].y /= (T)tp.y;
3532 tpPoints[1].x /= (T)tp.x;
3533 tpPoints[1].y /= (T)tp.y;
3534
3535 return *this;
3536 }
3537
3551 const TLine<T>& operator/=(const TPoint<double>& tp)
3552 {
3553 tpPoints[0].x /= (T)tp.x;
3554 tpPoints[0].y /= (T)tp.y;
3555 tpPoints[1].x /= (T)tp.x;
3556 tpPoints[1].y /= (T)tp.y;
3557
3558 return *this;
3559 }
3560
3572 const TLine<T>& operator/=(const TLine<int32_t>& tl)
3573 {
3574 tpPoints[0].x /= (T)tl.tpPoints[0].x;
3575 tpPoints[0].y /= (T)tl.tpPoints[0].y;
3576 tpPoints[1].x /= (T)tl.tpPoints[1].x;
3577 tpPoints[1].y /= (T)tl.tpPoints[1].y;
3578
3579 return *this;
3580 }
3581
3593 const TLine<T>& operator/=(const TLine<int64_t>& tl)
3594 {
3595 tpPoints[0].x /= (T)tl.tpPoints[0].x;
3596 tpPoints[0].y /= (T)tl.tpPoints[0].y;
3597 tpPoints[1].x /= (T)tl.tpPoints[1].x;
3598 tpPoints[1].y /= (T)tl.tpPoints[1].y;
3599
3600 return *this;
3601 }
3602
3614 const TLine<T>& operator/=(const TLine<float>& tl)
3615 {
3616 tpPoints[0].x /= (T)tl.tpPoints[0].x;
3617 tpPoints[0].y /= (T)tl.tpPoints[0].y;
3618 tpPoints[1].x /= (T)tl.tpPoints[1].x;
3619 tpPoints[1].y /= (T)tl.tpPoints[1].y;
3620
3621 return *this;
3622 }
3623
3635 const TLine<T>& operator/=(const TLine<double>& tl)
3636 {
3637 tpPoints[0].x /= (T)tl.tpPoints[0].x;
3638 tpPoints[0].y /= (T)tl.tpPoints[0].y;
3639 tpPoints[1].x /= (T)tl.tpPoints[1].x;
3640 tpPoints[1].y /= (T)tl.tpPoints[1].y;
3641
3642 return *this;
3643 }
3644
3656 TLine<T> operator+(int32_t value) const
3657 {
3658 TLine<T> tlReturn;
3659 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)value;
3660 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)value;
3661 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)value;
3662 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)value;
3663
3664 return tlReturn;
3665 }
3666
3678 TLine<T> operator+(int64_t value) const
3679 {
3680 TLine<T> tlReturn;
3681 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)value;
3682 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)value;
3683 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)value;
3684 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)value;
3685
3686 return tlReturn;
3687 }
3688
3700 TLine<T> operator+(float value) const
3701 {
3702 TLine<T> tlReturn;
3703 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)value;
3704 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)value;
3705 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)value;
3706 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)value;
3707
3708 return tlReturn;
3709 }
3710
3722 TLine<T> operator+(double value) const
3723 {
3724 TLine<T> tlReturn;
3725 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)value;
3726 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)value;
3727 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)value;
3728 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)value;
3729
3730 return tlReturn;
3731 }
3732
3746 TLine<T> operator+(const TPoint<int32_t>& tp) const
3747 {
3748 TLine<T> tlReturn;
3749 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)tp.x;
3750 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)tp.y;
3751 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)tp.x;
3752 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)tp.y;
3753
3754 return tlReturn;
3755 }
3756
3770 TLine<T> operator+(const TPoint<int64_t>& tp) const
3771 {
3772 TLine<T> tlReturn;
3773 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)tp.x;
3774 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)tp.y;
3775 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)tp.x;
3776 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)tp.y;
3777
3778 return tlReturn;
3779 }
3780
3794 TLine<T> operator+(const TPoint<float>& tp) const
3795 {
3796 TLine<T> tlReturn;
3797 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)tp.x;
3798 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)tp.y;
3799 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)tp.x;
3800 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)tp.y;
3801
3802 return tlReturn;
3803 }
3804
3818 TLine<T> operator+(const TPoint<double>& tp) const
3819 {
3820 TLine<T> tlReturn;
3821 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)tp.x;
3822 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)tp.y;
3823 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)tp.x;
3824 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)tp.y;
3825
3826 return tlReturn;
3827 }
3828
3840 TLine<T> operator+(const TLine<int32_t>& tl) const
3841 {
3842 TLine<T> tlReturn;
3843 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)tl.tpPoints[0].x;
3844 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)tl.tpPoints[0].y;
3845 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)tl.tpPoints[1].x;
3846 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)tl.tpPoints[1].y;
3847
3848 return tlReturn;
3849 }
3850
3862 TLine<T> operator+(const TLine<int64_t>& tl) const
3863 {
3864 TLine<T> tlReturn;
3865 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)tl.tpPoints[0].x;
3866 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)tl.tpPoints[0].y;
3867 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)tl.tpPoints[1].x;
3868 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)tl.tpPoints[1].y;
3869
3870 return tlReturn;
3871 }
3872
3884 TLine<T> operator+(const TLine<float>& tl) const
3885 {
3886 TLine<T> tlReturn;
3887 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)tl.tpPoints[0].x;
3888 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)tl.tpPoints[0].y;
3889 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)tl.tpPoints[1].x;
3890 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)tl.tpPoints[1].y;
3891
3892 return tlReturn;
3893 }
3894
3906 TLine<T> operator+(const TLine<double>& tl) const
3907 {
3908 TLine<T> tlReturn;
3909 tlReturn.tpPoints[0].x = tpPoints[0].x + (T)tl.tpPoints[0].x;
3910 tlReturn.tpPoints[0].y = tpPoints[0].y + (T)tl.tpPoints[0].y;
3911 tlReturn.tpPoints[1].x = tpPoints[1].x + (T)tl.tpPoints[1].x;
3912 tlReturn.tpPoints[1].y = tpPoints[1].y + (T)tl.tpPoints[1].y;
3913
3914 return tlReturn;
3915 }
3916
3928 TLine<T> operator-(int32_t value) const
3929 {
3930 TLine<T> tlReturn;
3931 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)value;
3932 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)value;
3933 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)value;
3934 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)value;
3935
3936 return tlReturn;
3937 }
3938
3950 TLine<T> operator-(int64_t value) const
3951 {
3952 TLine<T> tlReturn;
3953 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)value;
3954 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)value;
3955 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)value;
3956 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)value;
3957
3958 return tlReturn;
3959 }
3960
3972 TLine<T> operator-(float value) const
3973 {
3974 TLine<T> tlReturn;
3975 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)value;
3976 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)value;
3977 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)value;
3978 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)value;
3979
3980 return tlReturn;
3981 }
3982
3994 TLine<T> operator-(double value) const
3995 {
3996 TLine<T> tlReturn;
3997 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)value;
3998 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)value;
3999 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)value;
4000 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)value;
4001
4002 return tlReturn;
4003 }
4004
4018 TLine<T> operator-(const TPoint<int32_t>& tp) const
4019 {
4020 TLine<T> tlReturn;
4021 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)tp.x;
4022 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)tp.y;
4023 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)tp.x;
4024 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)tp.y;
4025
4026 return tlReturn;
4027 }
4028
4042 TLine<T> operator-(const TPoint<int64_t>& tp) const
4043 {
4044 TLine<T> tlReturn;
4045 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)tp.x;
4046 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)tp.y;
4047 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)tp.x;
4048 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)tp.y;
4049
4050 return tlReturn;
4051 }
4052
4066 TLine<T> operator-(const TPoint<float>& tp) const
4067 {
4068 TLine<T> tlReturn;
4069 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)tp.x;
4070 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)tp.y;
4071 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)tp.x;
4072 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)tp.y;
4073
4074 return tlReturn;
4075 }
4076
4090 TLine<T> operator-(const TPoint<double>& tp) const
4091 {
4092 TLine<T> tlReturn;
4093 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)tp.x;
4094 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)tp.y;
4095 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)tp.x;
4096 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)tp.y;
4097
4098 return tlReturn;
4099 }
4100
4112 TLine<T> operator-(const TLine<int32_t>& tl) const
4113 {
4114 TLine<T> tlReturn;
4115 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)tl.tpPoints[0].x;
4116 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)tl.tpPoints[0].y;
4117 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)tl.tpPoints[1].x;
4118 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)tl.tpPoints[1].y;
4119
4120 return tlReturn;
4121 }
4122
4134 TLine<T> operator-(const TLine<int64_t>& tl) const
4135 {
4136 TLine<T> tlReturn;
4137 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)tl.tpPoints[0].x;
4138 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)tl.tpPoints[0].y;
4139 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)tl.tpPoints[1].x;
4140 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)tl.tpPoints[1].y;
4141
4142 return tlReturn;
4143 }
4144
4156 TLine<T> operator-(const TLine<float>& tl) const
4157 {
4158 TLine<T> tlReturn;
4159 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)tl.tpPoints[0].x;
4160 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)tl.tpPoints[0].y;
4161 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)tl.tpPoints[1].x;
4162 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)tl.tpPoints[1].y;
4163
4164 return tlReturn;
4165 }
4166
4178 TLine<T> operator-(const TLine<double>& tl) const
4179 {
4180 TLine<T> tlReturn;
4181 tlReturn.tpPoints[0].x = tpPoints[0].x - (T)tl.tpPoints[0].x;
4182 tlReturn.tpPoints[0].y = tpPoints[0].y - (T)tl.tpPoints[0].y;
4183 tlReturn.tpPoints[1].x = tpPoints[1].x - (T)tl.tpPoints[1].x;
4184 tlReturn.tpPoints[1].y = tpPoints[1].y - (T)tl.tpPoints[1].y;
4185
4186 return tlReturn;
4187 }
4188
4200 TLine<T> operator*(int32_t value) const
4201 {
4202 TLine<T> tlReturn;
4203 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)value;
4204 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)value;
4205 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)value;
4206 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)value;
4207
4208 return tlReturn;
4209 }
4210
4222 TLine<T> operator*(int64_t value) const
4223 {
4224 TLine<T> tlReturn;
4225 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)value;
4226 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)value;
4227 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)value;
4228 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)value;
4229
4230 return tlReturn;
4231 }
4232
4244 TLine<T> operator*(float value) const
4245 {
4246 TLine<T> tlReturn;
4247 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)value;
4248 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)value;
4249 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)value;
4250 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)value;
4251
4252 return tlReturn;
4253 }
4254
4266 TLine<T> operator*(double value) const
4267 {
4268 TLine<T> tlReturn;
4269 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)value;
4270 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)value;
4271 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)value;
4272 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)value;
4273
4274 return tlReturn;
4275 }
4276
4290 TLine<T> operator*(const TPoint<int32_t>& tp) const
4291 {
4292 TLine<T> tlReturn;
4293 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)tp.x;
4294 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)tp.y;
4295 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)tp.x;
4296 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)tp.y;
4297
4298 return tlReturn;
4299 }
4300
4314 TLine<T> operator*(const TPoint<int64_t>& tp) const
4315 {
4316 TLine<T> tlReturn;
4317 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)tp.x;
4318 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)tp.y;
4319 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)tp.x;
4320 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)tp.y;
4321
4322 return tlReturn;
4323 }
4324
4338 TLine<T> operator*(const TPoint<float>& tp) const
4339 {
4340 TLine<T> tlReturn;
4341 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)tp.x;
4342 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)tp.y;
4343 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)tp.x;
4344 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)tp.y;
4345
4346 return tlReturn;
4347 }
4348
4362 TLine<T> operator*(const TPoint<double>& tp) const
4363 {
4364 TLine<T> tlReturn;
4365 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)tp.x;
4366 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)tp.y;
4367 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)tp.x;
4368 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)tp.y;
4369
4370 return tlReturn;
4371 }
4372
4384 TLine<T> operator*(const TLine<int32_t>& tl) const
4385 {
4386 TLine<T> tlReturn;
4387 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)tl.tpPoints[0].x;
4388 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)tl.tpPoints[0].y;
4389 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)tl.tpPoints[1].x;
4390 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)tl.tpPoints[1].y;
4391
4392 return tlReturn;
4393 }
4394
4406 TLine<T> operator*(const TLine<int64_t>& tl) const
4407 {
4408 TLine<T> tlReturn;
4409 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)tl.tpPoints[0].x;
4410 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)tl.tpPoints[0].y;
4411 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)tl.tpPoints[1].x;
4412 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)tl.tpPoints[1].y;
4413
4414 return tlReturn;
4415 }
4416
4428 TLine<T> operator*(const TLine<float>& tl) const
4429 {
4430 TLine<T> tlReturn;
4431 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)tl.tpPoints[0].x;
4432 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)tl.tpPoints[0].y;
4433 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)tl.tpPoints[1].x;
4434 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)tl.tpPoints[1].y;
4435
4436 return tlReturn;
4437 }
4438
4450 TLine<T> operator*(const TLine<double>& tl) const
4451 {
4452 TLine<T> tlReturn;
4453 tlReturn.tpPoints[0].x = tpPoints[0].x * (T)tl.tpPoints[0].x;
4454 tlReturn.tpPoints[0].y = tpPoints[0].y * (T)tl.tpPoints[0].y;
4455 tlReturn.tpPoints[1].x = tpPoints[1].x * (T)tl.tpPoints[1].x;
4456 tlReturn.tpPoints[1].y = tpPoints[1].y * (T)tl.tpPoints[1].y;
4457
4458 return tlReturn;
4459 }
4460
4472 TLine<T> operator/(int32_t value) const
4473 {
4474 TLine<T> tlReturn;
4475 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)value;
4476 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)value;
4477 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)value;
4478 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)value;
4479
4480 return tlReturn;
4481 }
4482
4494 TLine<T> operator/(int64_t value) const
4495 {
4496 TLine<T> tlReturn;
4497 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)value;
4498 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)value;
4499 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)value;
4500 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)value;
4501
4502 return tlReturn;
4503 }
4504
4516 TLine<T> operator/(float value) const
4517 {
4518 TLine<T> tlReturn;
4519 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)value;
4520 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)value;
4521 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)value;
4522 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)value;
4523
4524 return tlReturn;
4525 }
4526
4538 TLine<T> operator/(double value) const
4539 {
4540 TLine<T> tlReturn;
4541 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)value;
4542 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)value;
4543 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)value;
4544 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)value;
4545
4546 return tlReturn;
4547 }
4548
4562 TLine<T> operator/(const TPoint<int32_t>& tp) const
4563 {
4564 TLine<T> tlReturn;
4565 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)tp.x;
4566 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)tp.y;
4567 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)tp.x;
4568 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)tp.y;
4569
4570 return tlReturn;
4571 }
4572
4586 TLine<T> operator/(const TPoint<int64_t>& tp) const
4587 {
4588 TLine<T> tlReturn;
4589 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)tp.x;
4590 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)tp.y;
4591 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)tp.x;
4592 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)tp.y;
4593
4594 return tlReturn;
4595 }
4596
4610 TLine<T> operator/(const TPoint<float>& tp) const
4611 {
4612 TLine<T> tlReturn;
4613 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)tp.x;
4614 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)tp.y;
4615 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)tp.x;
4616 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)tp.y;
4617
4618 return tlReturn;
4619 }
4620
4634 TLine<T> operator/(const TPoint<double>& tp) const
4635 {
4636 TLine<T> tlReturn;
4637 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)tp.x;
4638 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)tp.y;
4639 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)tp.x;
4640 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)tp.y;
4641
4642 return tlReturn;
4643 }
4644
4656 TLine<T> operator/(const TLine<int32_t>& tl) const
4657 {
4658 TLine<T> tlReturn;
4659 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)tl.tpPoints[0].x;
4660 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)tl.tpPoints[0].y;
4661 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)tl.tpPoints[1].x;
4662 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)tl.tpPoints[1].y;
4663
4664 return tlReturn;
4665 }
4666
4678 TLine<T> operator/(const TLine<int64_t>& tl) const
4679 {
4680 TLine<T> tlReturn;
4681 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)tl.tpPoints[0].x;
4682 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)tl.tpPoints[0].y;
4683 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)tl.tpPoints[1].x;
4684 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)tl.tpPoints[1].y;
4685
4686 return tlReturn;
4687 }
4688
4700 TLine<T> operator/(const TLine<float>& tl) const
4701 {
4702 TLine<T> tlReturn;
4703 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)tl.tpPoints[0].x;
4704 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)tl.tpPoints[0].y;
4705 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)tl.tpPoints[1].x;
4706 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)tl.tpPoints[1].y;
4707
4708 return tlReturn;
4709 }
4710
4722 TLine<T> operator/(const TLine<double>& tl) const
4723 {
4724 TLine<T> tlReturn;
4725 tlReturn.tpPoints[0].x = tpPoints[0].x / (T)tl.tpPoints[0].x;
4726 tlReturn.tpPoints[0].y = tpPoints[0].y / (T)tl.tpPoints[0].y;
4727 tlReturn.tpPoints[1].x = tpPoints[1].x / (T)tl.tpPoints[1].x;
4728 tlReturn.tpPoints[1].y = tpPoints[1].y / (T)tl.tpPoints[1].y;
4729
4730 return tlReturn;
4731 }
4732
4746 friend TLine<T> operator+(int32_t value, const TLine<T>& tl)
4747 {
4748 return TLine<T>((T)value + tl.tpPoints[0].x, (T)value + tl.tpPoints[0].y, (T)value + tl.tpPoints[1].x, (T)value + tl.tpPoints[1].y);
4749 }
4750
4764 friend TLine<T> operator+(int64_t value, const TLine<T>& tl)
4765 {
4766 return TLine<T>((T)value + tl.tpPoints[0].x, (T)value + tl.tpPoints[0].y, (T)value + tl.tpPoints[1].x, (T)value + tl.tpPoints[1].y);
4767 }
4768
4782 friend TLine<T> operator+(float value, const TLine<T>& tl)
4783 {
4784 return TLine<T>((T)value + tl.tpPoints[0].x, (T)value + tl.tpPoints[0].y, (T)value + tl.tpPoints[1].x, (T)value + tl.tpPoints[1].y);
4785 }
4786
4800 friend TLine<T> operator+(double value, const TLine<T>& tl)
4801 {
4802 return TLine<T>((T)value + tl.tpPoints[0].x, (T)value + tl.tpPoints[0].y, (T)value + tl.tpPoints[1].x, (T)value + tl.tpPoints[1].y);
4803 }
4804
4820 friend TLine<T> operator+(const TPoint<int32_t>& tp, const TLine<T>& tl)
4821 {
4822 return TLine<T>((T)tp.x + tl.tpPoints[0].x, (T)tp.y + tl.tpPoints[0].y, (T)tp.x + tl.tpPoints[1].x, (T)tp.y + tl.tpPoints[1].y);
4823 }
4824
4840 friend TLine<T> operator+(const TPoint<int64_t>& tp, const TLine<T>& tl)
4841 {
4842 return TLine<T>((T)tp.x + tl.tpPoints[0].x, (T)tp.y + tl.tpPoints[0].y, (T)tp.x + tl.tpPoints[1].x, (T)tp.y + tl.tpPoints[1].y);
4843 }
4844
4860 friend TLine<T> operator+(const TPoint<float>& tp, const TLine<T>& tl)
4861 {
4862 return TLine<T>((T)tp.x + tl.tpPoints[0].x, (T)tp.y + tl.tpPoints[0].y, (T)tp.x + tl.tpPoints[1].x, (T)tp.y + tl.tpPoints[1].y);
4863 }
4864
4880 friend TLine<T> operator+(const TPoint<double>& tp, const TLine<T>& tl)
4881 {
4882 return TLine<T>((T)tp.x + tl.tpPoints[0].x, (T)tp.y + tl.tpPoints[0].y, (T)tp.x + tl.tpPoints[1].x, (T)tp.y + tl.tpPoints[1].y);
4883 }
4884
4898 friend TLine<T> operator-(int32_t value, const TLine<T>& tl)
4899 {
4900 return TLine<T>((T)value - tl.tpPoints[0].x, (T)value - tl.tpPoints[0].y, (T)value - tl.tpPoints[1].x, (T)value - tl.tpPoints[1].y);
4901 }
4902
4916 friend TLine<T> operator-(int64_t value, const TLine<T>& tl)
4917 {
4918 return TLine<T>((T)value - tl.tpPoints[0].x, (T)value - tl.tpPoints[0].y, (T)value - tl.tpPoints[1].x, (T)value - tl.tpPoints[1].y);
4919 }
4920
4934 friend TLine<T> operator-(float value, const TLine<T>& tl)
4935 {
4936 return TLine<T>((T)value - tl.tpPoints[0].x, (T)value - tl.tpPoints[0].y, (T)value - tl.tpPoints[1].x, (T)value - tl.tpPoints[1].y);
4937 }
4938
4952 friend TLine<T> operator-(double value, const TLine<T>& tl)
4953 {
4954 return TLine<T>((T)value - tl.tpPoints[0].x, (T)value - tl.tpPoints[0].y, (T)value - tl.tpPoints[1].x, (T)value - tl.tpPoints[1].y);
4955 }
4956
4972 friend TLine<T> operator-(const TPoint<int32_t>& tp, const TLine<T>& tl)
4973 {
4974 return TLine<T>((T)tp.x - tl.tpPoints[0].x, (T)tp.y - tl.tpPoints[0].y, (T)tp.x - tl.tpPoints[1].x, (T)tp.y - tl.tpPoints[1].y);
4975 }
4976
4992 friend TLine<T> operator-(const TPoint<int64_t>& tp, const TLine<T>& tl)
4993 {
4994 return TLine<T>((T)tp.x - tl.tpPoints[0].x, (T)tp.y - tl.tpPoints[0].y, (T)tp.x - tl.tpPoints[1].x, (T)tp.y - tl.tpPoints[1].y);
4995 }
4996
5012 friend TLine<T> operator-(const TPoint<float>& tp, const TLine<T>& tl)
5013 {
5014 return TLine<T>((T)tp.x - tl.tpPoints[0].x, (T)tp.y - tl.tpPoints[0].y, (T)tp.x - tl.tpPoints[1].x, (T)tp.y - tl.tpPoints[1].y);
5015 }
5016
5032 friend TLine<T> operator-(const TPoint<double>& tp, const TLine<T>& tl)
5033 {
5034 return TLine<T>((T)tp.x - tl.tpPoints[0].x, (T)tp.y - tl.tpPoints[0].y, (T)tp.x - tl.tpPoints[1].x, (T)tp.y - tl.tpPoints[1].y);
5035 }
5036
5050 friend TLine<T> operator*(int32_t value, const TLine<T>& tl)
5051 {
5052 return TLine<T>((T)value * tl.tpPoints[0].x, (T)value * tl.tpPoints[0].y, (T)value * tl.tpPoints[1].x, (T)value * tl.tpPoints[1].y);
5053 }
5054
5068 friend TLine<T> operator*(int64_t value, const TLine<T>& tl)
5069 {
5070 return TLine<T>((T)value * tl.tpPoints[0].x, (T)value * tl.tpPoints[0].y, (T)value * tl.tpPoints[1].x, (T)value * tl.tpPoints[1].y);
5071 }
5072
5086 friend TLine<T> operator*(float value, const TLine<T>& tl)
5087 {
5088 return TLine<T>((T)value * tl.tpPoints[0].x, (T)value * tl.tpPoints[0].y, (T)value * tl.tpPoints[1].x, (T)value * tl.tpPoints[1].y);
5089 }
5090
5104 friend TLine<T> operator*(double value, const TLine<T>& tl)
5105 {
5106 return TLine<T>((T)value * tl.tpPoints[0].x, (T)value * tl.tpPoints[0].y, (T)value * tl.tpPoints[1].x, (T)value * tl.tpPoints[1].y);
5107 }
5108
5124 friend TLine<T> operator*(const TPoint<int32_t>& tp, const TLine<T>& tl)
5125 {
5126 return TLine<T>((T)tp.x * tl.tpPoints[0].x, (T)tp.y * tl.tpPoints[0].y, (T)tp.x * tl.tpPoints[1].x, (T)tp.y * tl.tpPoints[1].y);
5127 }
5128
5144 friend TLine<T> operator*(const TPoint<int64_t>& tp, const TLine<T>& tl)
5145 {
5146 return TLine<T>((T)tp.x * tl.tpPoints[0].x, (T)tp.y * tl.tpPoints[0].y, (T)tp.x * tl.tpPoints[1].x, (T)tp.y * tl.tpPoints[1].y);
5147 }
5148
5164 friend TLine<T> operator*(const TPoint<float>& tp, const TLine<T>& tl)
5165 {
5166 return TLine<T>((T)tp.x * tl.tpPoints[0].x, (T)tp.y * tl.tpPoints[0].y, (T)tp.x * tl.tpPoints[1].x, (T)tp.y * tl.tpPoints[1].y);
5167 }
5168
5184 friend TLine<T> operator*(const TPoint<double>& tp, const TLine<T>& tl)
5185 {
5186 return TLine<T>((T)tp.x * tl.tpPoints[0].x, (T)tp.y * tl.tpPoints[0].y, (T)tp.x * tl.tpPoints[1].x, (T)tp.y * tl.tpPoints[1].y);
5187 }
5188
5202 friend TLine<T> operator/(int32_t value, const TLine<T>& tl)
5203 {
5204 return TLine<T>((T)value / tl.tpPoints[0].x, (T)value / tl.tpPoints[0].y, (T)value / tl.tpPoints[1].x, (T)value / tl.tpPoints[1].y);
5205 }
5206
5220 friend TLine<T> operator/(int64_t value, const TLine<T>& tl)
5221 {
5222 return TLine<T>((T)value / tl.tpPoints[0].x, (T)value / tl.tpPoints[0].y, (T)value / tl.tpPoints[1].x, (T)value / tl.tpPoints[1].y);
5223 }
5224
5238 friend TLine<T> operator/(float value, const TLine<T>& tl)
5239 {
5240 return TLine<T>((T)value / tl.tpPoints[0].x, (T)value / tl.tpPoints[0].y, (T)value / tl.tpPoints[1].x, (T)value / tl.tpPoints[1].y);
5241 }
5242
5256 friend TLine<T> operator/(double value, const TLine<T>& tl)
5257 {
5258 return TLine<T>((T)value / tl.tpPoints[0].x, (T)value / tl.tpPoints[0].y, (T)value / tl.tpPoints[1].x, (T)value / tl.tpPoints[1].y);
5259 }
5260
5276 friend TLine<T> operator/(const TPoint<int32_t>& tp, const TLine<T>& tl)
5277 {
5278 return TLine<T>((T)tp.x / tl.tpPoints[0].x, (T)tp.y / tl.tpPoints[0].y, (T)tp.x / tl.tpPoints[1].x, (T)tp.y / tl.tpPoints[1].y);
5279 }
5280
5296 friend TLine<T> operator/(const TPoint<int64_t>& tp, const TLine<T>& tl)
5297 {
5298 return TLine<T>((T)tp.x / tl.tpPoints[0].x, (T)tp.y / tl.tpPoints[0].y, (T)tp.x / tl.tpPoints[1].x, (T)tp.y / tl.tpPoints[1].y);
5299 }
5300
5316 friend TLine<T> operator/(const TPoint<float>& tp, const TLine<T>& tl)
5317 {
5318 return TLine<T>((T)tp.x / tl.tpPoints[0].x, (T)tp.y / tl.tpPoints[0].y, (T)tp.x / tl.tpPoints[1].x, (T)tp.y / tl.tpPoints[1].y);
5319 }
5320
5336 friend TLine<T> operator/(const TPoint<double>& tp, const TLine<T>& tl)
5337 {
5338 return TLine<T>((T)tp.x / tl.tpPoints[0].x, (T)tp.y / tl.tpPoints[0].y, (T)tp.x / tl.tpPoints[1].x, (T)tp.y / tl.tpPoints[1].y);
5339 }
5340 };
5341 #pragma pack(pop)
5342
5343 typedef TLine<int8_t> TLineC;
5344 typedef TLine<uint8_t> TLineUC;
5345 typedef TLine<int16_t> TLineS;
5346 typedef TLine<uint16_t> TLineUS;
5347 typedef TLine<int32_t> TLineL;
5348 typedef TLine<uint32_t> TLineUL;
5349 typedef TLine<int64_t> TLineLL;
5350 typedef TLine<uint64_t> TLineULL;
5351 typedef TLine<float> TLineF;
5352 typedef TLine<double> TLineD;
5353 }
5354}
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(const TLine< int64_t > &tl)
직선 객체를 대입합니다.
Definition TLine.h:2425
FLImaging::Base::TLine::operator!=
bool operator!=(const TLine< int64_t > &tl) const
비교 연산자
Definition TLine.h:2568
FLImaging::Base::TLine::operator+
TLine< T > operator+(const TPoint< double > &tp) const
덧셈 연산자
Definition TLine.h:3818
FLImaging::Base::TLine::TLine
TLine(int8_t x0, int8_t y0, int8_t x1, int8_t y1)
초기화 생성자
Definition TLine.h:932
FLImaging::Base::TLine::operator-
TLine< T > operator-(int32_t value) const
뺄셈 연산자
Definition TLine.h:3928
FLImaging::Base::TLine::operator*
TLine< T > operator*(const TPoint< int32_t > &tp) const
곱셈 연산자
Definition TLine.h:4290
FLImaging::Base::TLine::Set
void Set(const TPoint< int16_t > *pTp0, const TPoint< int16_t > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1649
FLImaging::Base::TLine::operator/
friend TLine< T > operator/(int32_t value, const TLine< T > &tl)
나눗셈 연산자
Definition TLine.h:5202
FLImaging::Base::TLine::operator/
friend TLine< T > operator/(int64_t value, const TLine< T > &tl)
나눗셈 연산자
Definition TLine.h:5220
FLImaging::Base::TLine::TLine
TLine(uint64_t x0, uint64_t y0, uint64_t x1, uint64_t y1)
초기화 생성자
Definition TLine.h:1093
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(const TPoint< int64_t > &tp)
곱셈 대입 연산자
Definition TLine.h:3245
FLImaging::Base::TLine::operator-
TLine< T > operator-(const TPoint< int32_t > &tp) const
뺄셈 연산자
Definition TLine.h:4018
FLImaging::Base::TLine::Set
void Set(int64_t x0, int64_t y0, int64_t x1, int64_t y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2160
FLImaging::Base::TLine::Set
void Set(int8_t x0, int8_t y0, int8_t x1, int8_t y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2022
FLImaging::Base::TLine::TLine
TLine(const TLine< int8_t > &tl)
복사 생성자
Definition TLine.h:66
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(int64_t value)
나눗셈 대입 연산자
Definition TLine.h:3417
FLImaging::Base::TLine::TLine
TLine(const TPoint< uint8_t > &tp0, const TPoint< uint8_t > &tp1)
초기화 생성자
Definition TLine.h:489
FLImaging::Base::TLine::TLine
TLine(const TLine< uint64_t > &tl)
복사 생성자
Definition TLine.h:325
FLImaging::Base::TLine::Set
void Set(const TPoint< int32_t > *pTp0, const TPoint< int32_t > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1747
FLImaging::Base::TLine::operator-
TLine< T > operator-(int64_t value) const
뺄셈 연산자
Definition TLine.h:3950
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(const TLine< double > &tl)
나눗셈 대입 연산자
Definition TLine.h:3635
FLImaging::Base::TLine::operator*
TLine< T > operator*(int64_t value) const
곱셈 연산자
Definition TLine.h:4222
FLImaging::Base::TLine::TLine
TLine(const TLine< uint64_t > *pTl)
복사 생성자
Definition TLine.h:342
FLImaging::Base::TLine::operator!=
bool operator!=(const TLine< int32_t > &tl) const
비교 연산자
Definition TLine.h:2552
FLImaging::Base::TLine::operator/
friend TLine< T > operator/(const TPoint< float > &tp, const TLine< T > &tl)
나눗셈 연산자
Definition TLine.h:5316
FLImaging::Base::TLine::operator-
friend TLine< T > operator-(const TPoint< double > &tp, const TLine< T > &tl)
뺄셈 연산자
Definition TLine.h:5032
FLImaging::Base::TLine::Set
void Set(const TLine< uint32_t > *pTl)
직선을 설정합니다.
Definition TLine.h:1358
FLImaging::Base::TLine::Set
void Set(const TPoint< int64_t > &tp0, const TPoint< int64_t > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1824
FLImaging::Base::TLine::operator-
TLine< T > operator-(const TLine< int64_t > &tl) const
뺄셈 연산자
Definition TLine.h:4134
FLImaging::Base::TLine::TLine
TLine(const TLine< uint32_t > &tl)
복사 생성자
Definition TLine.h:251
FLImaging::Base::TLine::operator/
friend TLine< T > operator/(const TPoint< int32_t > &tp, const TLine< T > &tl)
나눗셈 연산자
Definition TLine.h:5276
FLImaging::Base::TLine::operator/
TLine< T > operator/(const TPoint< int64_t > &tp) const
나눗셈 연산자
Definition TLine.h:4586
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(const TLine< int32_t > &tl)
뺄셈 대입 연산자
Definition TLine.h:3052
FLImaging::Base::TLine::operator+
TLine< T > operator+(const TLine< int32_t > &tl) const
덧셈 연산자
Definition TLine.h:3840
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(const TLine< double > &tl)
직선 객체를 대입합니다.
Definition TLine.h:2467
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(int32_t value)
곱셈 대입 연산자
Definition TLine.h:3136
FLImaging::Base::TLine::TLine
TLine(const TPoint< double > *pTp0, const TPoint< double > *pTp1)
초기화 생성자
Definition TLine.h:902
FLImaging::Base::TLine::operator-
friend TLine< T > operator-(double value, const TLine< T > &tl)
뺄셈 연산자
Definition TLine.h:4952
FLImaging::Base::TLine::Set
void Set(const TLine< int64_t > *pTl)
직선을 설정합니다.
Definition TLine.h:1395
FLImaging::Base::TLine::Set
void Set(const TLine< uint32_t > &tl)
직선을 설정합니다.
Definition TLine.h:1341
FLImaging::Base::TLine::operator/
TLine< T > operator/(int32_t value) const
나눗셈 연산자
Definition TLine.h:4472
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(const TPoint< int64_t > &tp)
나눗셈 대입 연산자
Definition TLine.h:3505
FLImaging::Base::TLine::operator+
friend TLine< T > operator+(const TPoint< float > &tp, const TLine< T > &tl)
덧셈 연산자
Definition TLine.h:4860
FLImaging::Base::TLine::Set
void Set(const TPoint< uint8_t > &tp0, const TPoint< uint8_t > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1579
FLImaging::Base::TLine::operator/
friend TLine< T > operator/(const TPoint< double > &tp, const TLine< T > &tl)
나눗셈 연산자
Definition TLine.h:5336
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(const TPoint< double > &tp)
직선의 모든 정점에 동일한 점 값을 대입합니다.
Definition TLine.h:2385
FLImaging::Base::TLine::Set
void Set(const TPoint< double > &tp0, const TPoint< double > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1971
FLImaging::Base::TLine::operator*
TLine< T > operator*(const TPoint< int64_t > &tp) const
곱셈 연산자
Definition TLine.h:4314
FLImaging::Base::TLine::Set
void Set(const TLine< uint16_t > &tl)
직선을 설정합니다.
Definition TLine.h:1267
FLImaging::Base::TLine::operator-
friend TLine< T > operator-(const TPoint< int64_t > &tp, const TLine< T > &tl)
뺄셈 연산자
Definition TLine.h:4992
FLImaging::Base::TLine::Set
void Set(const TLine< int32_t > &tl)
직선을 설정합니다.
Definition TLine.h:1304
FLImaging::Base::TLine::TLine
TLine(const TPoint< float > &tp0, const TPoint< float > &tp1)
초기화 생성자
Definition TLine.h:832
FLImaging::Base::TLine::operator==
bool operator==(const TLine< float > &tl) const
비교 연산자
Definition TLine.h:2520
FLImaging::Base::TLine::operator/
TLine< T > operator/(const TPoint< float > &tp) const
나눗셈 연산자
Definition TLine.h:4610
FLImaging::Base::TLine::Set
void Set(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2045
FLImaging::Base::TLine::Set
void Set(double x0, double y0, double x1, double y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2229
FLImaging::Base::TLine::operator/
friend TLine< T > operator/(float value, const TLine< T > &tl)
나눗셈 연산자
Definition TLine.h:5238
FLImaging::Base::TLine::operator-
TLine< T > operator-(const TLine< float > &tl) const
뺄셈 연산자
Definition TLine.h:4156
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(int64_t value)
덧셈 대입 연산자
Definition TLine.h:2637
FLImaging::Base::TLine::operator/
friend TLine< T > operator/(double value, const TLine< T > &tl)
나눗셈 연산자
Definition TLine.h:5256
FLImaging::Base::TLine::Set
void Set(const TLine< double > *pTl)
직선을 설정합니다.
Definition TLine.h:1506
FLImaging::Base::TLine::operator+
friend TLine< T > operator+(float value, const TLine< T > &tl)
덧셈 연산자
Definition TLine.h:4782
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(const TPoint< float > &tp)
뺄셈 대입 연산자
Definition TLine.h:3008
FLImaging::Base::TLine::TLine
TLine(const TPoint< double > &tp0, const TPoint< double > &tp1)
초기화 생성자
Definition TLine.h:881
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(const TLine< double > &tl)
덧셈 대입 연산자
Definition TLine.h:2855
FLImaging::Base::TLine::Set
void Set(const TPoint< int16_t > &tp0, const TPoint< int16_t > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1628
FLImaging::Base::TLine::TLine
TLine(const TLine< float > *pTl)
복사 생성자
Definition TLine.h:379
FLImaging::Base::TLine::Set
void Set(const TLine< uint64_t > &tl)
직선을 설정합니다.
Definition TLine.h:1415
FLImaging::Base::TLine::TLine
TLine()
기본 생성자
Definition TLine.h:53
FLImaging::Base::TLine::operator+
TLine< T > operator+(int64_t value) const
덧셈 연산자
Definition TLine.h:3678
FLImaging::Base::TLine::TLine
TLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
초기화 생성자
Definition TLine.h:1001
FLImaging::Base::TLine::operator*
TLine< T > operator*(const TLine< int64_t > &tl) const
곱셈 연산자
Definition TLine.h:4406
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(const TLine< int32_t > &tl)
덧셈 대입 연산자
Definition TLine.h:2792
FLImaging::Base::TLine::TLine
TLine(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1)
초기화 생성자
Definition TLine.h:1047
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(const TPoint< float > &tp)
직선의 모든 정점에 동일한 점 값을 대입합니다.
Definition TLine.h:2364
FLImaging::Base::TLine::operator*
friend TLine< T > operator*(const TPoint< int64_t > &tp, const TLine< T > &tl)
곱셈 연산자
Definition TLine.h:5144
FLImaging::Base::TLine::operator/
TLine< T > operator/(const TLine< int32_t > &tl) const
나눗셈 연산자
Definition TLine.h:4656
FLImaging::Base::TLine::operator/
friend TLine< T > operator/(const TPoint< int64_t > &tp, const TLine< T > &tl)
나눗셈 연산자
Definition TLine.h:5296
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(float value)
나눗셈 대입 연산자
Definition TLine.h:3438
FLImaging::Base::TLine::TLine
TLine(const TPoint< int32_t > &tp0, const TPoint< int32_t > &tp1)
초기화 생성자
Definition TLine.h:636
FLImaging::Base::TLine::Set
void Set(const TPoint< uint32_t > &tp0, const TPoint< uint32_t > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1775
FLImaging::Base::TLine::operator+
TLine< T > operator+(int32_t value) const
덧셈 연산자
Definition TLine.h:3656
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(const TLine< double > &tl)
뺄셈 대입 연산자
Definition TLine.h:3115
FLImaging::Base::TLine::Set
void Set(const TLine< int8_t > &tl)
직선을 설정합니다.
Definition TLine.h:1156
FLImaging::Base::TLine::TLine
TLine(const TLine< uint32_t > *pTl)
복사 생성자
Definition TLine.h:268
FLImaging::Base::TLine::Set
void Set(const TLine< uint64_t > *pTl)
직선을 설정합니다.
Definition TLine.h:1432
FLImaging::Base::TLine::TLine
TLine(const TPoint< uint64_t > *pTp0, const TPoint< uint64_t > *pTp1)
초기화 생성자
Definition TLine.h:804
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(const TPoint< int32_t > &tp)
직선의 모든 정점에 동일한 점 값을 대입합니다.
Definition TLine.h:2322
FLImaging::Base::TLine::TLine
TLine(const TLine< int64_t > &tl)
복사 생성자
Definition TLine.h:288
FLImaging::Base::TLine::Set
void Set(const TLine< uint8_t > *pTl)
직선을 설정합니다.
Definition TLine.h:1210
FLImaging::Base::TLine::Set
void Set(const TPoint< uint16_t > *pTp0, const TPoint< uint16_t > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1698
FLImaging::Base::TLine::operator+
TLine< T > operator+(double value) const
덧셈 연산자
Definition TLine.h:3722
FLImaging::Base::TLine::Set
void Set(const TLine< double > &tl)
직선을 설정합니다.
Definition TLine.h:1489
FLImaging::Base::TLine::TLine
TLine(const TPoint< int64_t > &tp0, const TPoint< int64_t > &tp1)
초기화 생성자
Definition TLine.h:734
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(double value)
나눗셈 대입 연산자
Definition TLine.h:3459
FLImaging::Base::TLine::Set
void Set(const TPoint< int8_t > *pTp0, const TPoint< int8_t > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1551
FLImaging::Base::TLine::TLine
TLine(const TPoint< int16_t > &tp0, const TPoint< int16_t > &tp1)
초기화 생성자
Definition TLine.h:538
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(double value)
직선의 모든 좌표에 동일한 값을 대입합니다.
Definition TLine.h:2302
FLImaging::Base::TLine::TLine
TLine(const TLine< uint8_t > *pTl)
복사 생성자
Definition TLine.h:120
FLImaging::Base::TLine::TLine
TLine(const TPoint< int16_t > *pTp0, const TPoint< int16_t > *pTp1)
초기화 생성자
Definition TLine.h:559
FLImaging::Base::TLine::TLine
TLine(const TPoint< int32_t > *pTp0, const TPoint< int32_t > *pTp1)
초기화 생성자
Definition TLine.h:657
FLImaging::Base::TLine::Set
void Set(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2137
FLImaging::Base::TLine::operator+
friend TLine< T > operator+(const TPoint< double > &tp, const TLine< T > &tl)
덧셈 연산자
Definition TLine.h:4880
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(const TPoint< int64_t > &tp)
뺄셈 대입 연산자
Definition TLine.h:2985
FLImaging::Base::TLine::Set
void Set(const TPoint< int64_t > *pTp0, const TPoint< int64_t > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1845
FLImaging::Base::TLine::Set
void Set(const TLine< uint16_t > *pTl)
직선을 설정합니다.
Definition TLine.h:1284
FLImaging::Base::TLine::operator+
TLine< T > operator+(const TLine< double > &tl) const
덧셈 연산자
Definition TLine.h:3906
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(float value)
뺄셈 대입 연산자
Definition TLine.h:2918
FLImaging::Base::TLine::Set
void Set(const TPoint< int32_t > &tp0, const TPoint< int32_t > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1726
FLImaging::Base::TLine::operator+
friend TLine< T > operator+(const TPoint< int64_t > &tp, const TLine< T > &tl)
덧셈 연산자
Definition TLine.h:4840
FLImaging::Base::TLine::operator+
TLine< T > operator+(float value) const
덧셈 연산자
Definition TLine.h:3700
FLImaging::Base::TLine::operator+
friend TLine< T > operator+(double value, const TLine< T > &tl)
덧셈 연산자
Definition TLine.h:4800
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(const TPoint< float > &tp)
나눗셈 대입 연산자
Definition TLine.h:3528
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(const TLine< int64_t > &tl)
나눗셈 대입 연산자
Definition TLine.h:3593
FLImaging::Base::TLine::operator-
friend TLine< T > operator-(int32_t value, const TLine< T > &tl)
뺄셈 연산자
Definition TLine.h:4898
FLImaging::Base::TLine::TLine
TLine(const TLine< float > &tl)
복사 생성자
Definition TLine.h:362
FLImaging::Base::TLine::TLine
TLine(const TLine< uint8_t > &tl)
복사 생성자
Definition TLine.h:103
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(const TLine< float > &tl)
뺄셈 대입 연산자
Definition TLine.h:3094
FLImaging::Base::TLine::operator/
TLine< T > operator/(const TPoint< int32_t > &tp) const
나눗셈 연산자
Definition TLine.h:4562
FLImaging::Base::TLine::operator/
TLine< T > operator/(const TLine< double > &tl) const
나눗셈 연산자
Definition TLine.h:4722
FLImaging::Base::TLine::TLine
TLine(int64_t x0, int64_t y0, int64_t x1, int64_t y1)
초기화 생성자
Definition TLine.h:1070
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(int32_t value)
덧셈 대입 연산자
Definition TLine.h:2616
FLImaging::Base::TLine::TLine
TLine(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1)
초기화 생성자
Definition TLine.h:955
FLImaging::Base::TLine::Set
void Set(const TLine< int32_t > *pTl)
직선을 설정합니다.
Definition TLine.h:1321
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(const TLine< float > &tl)
직선 객체를 대입합니다.
Definition TLine.h:2446
FLImaging::Base::TLine::operator==
bool operator==(const TLine< int32_t > &tl) const
비교 연산자
Definition TLine.h:2488
FLImaging::Base::TLine::Set
void Set(const TLine< int8_t > *pTl)
직선을 설정합니다.
Definition TLine.h:1173
FLImaging::Base::TLine::Set
void Set(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2091
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(const TPoint< int64_t > &tp)
덧셈 대입 연산자
Definition TLine.h:2725
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(const TLine< int32_t > &tl)
나눗셈 대입 연산자
Definition TLine.h:3572
FLImaging::Base::TLine::Set
void Set(const TPoint< double > *pTp0, const TPoint< double > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1992
FLImaging::Base::TLine::operator-
friend TLine< T > operator-(const TPoint< float > &tp, const TLine< T > &tl)
뺄셈 연산자
Definition TLine.h:5012
FLImaging::Base::TLine::Set
void Set(const TPoint< float > &tp0, const TPoint< float > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1922
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(const TLine< int32_t > &tl)
직선 객체를 대입합니다.
Definition TLine.h:2404
FLImaging::Base::TLine::operator*
friend TLine< T > operator*(int64_t value, const TLine< T > &tl)
곱셈 연산자
Definition TLine.h:5068
FLImaging::Base::TLine::operator==
bool operator==(const TLine< double > &tl) const
비교 연산자
Definition TLine.h:2536
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(const TLine< double > &tl)
곱셈 대입 연산자
Definition TLine.h:3375
FLImaging::Base::TLine::TLine
TLine(const TPoint< int8_t > &tp0, const TPoint< int8_t > &tp1)
초기화 생성자
Definition TLine.h:440
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(float value)
곱셈 대입 연산자
Definition TLine.h:3178
FLImaging::Base::TLine::operator+
friend TLine< T > operator+(int64_t value, const TLine< T > &tl)
덧셈 연산자
Definition TLine.h:4764
FLImaging::Base::TLine::operator-
TLine< T > operator-(const TPoint< int64_t > &tp) const
뺄셈 연산자
Definition TLine.h:4042
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(const TPoint< float > &tp)
곱셈 대입 연산자
Definition TLine.h:3268
FLImaging::Base::TLine::Set
void Set(const TLine< float > &tl)
직선을 설정합니다.
Definition TLine.h:1452
FLImaging::Base::TLine::TLine
TLine(const TLine< int32_t > &tl)
복사 생성자
Definition TLine.h:214
FLImaging::Base::TLine::operator*
TLine< T > operator*(const TPoint< double > &tp) const
곱셈 연산자
Definition TLine.h:4362
FLImaging::Base::TLine::operator/
TLine< T > operator/(int64_t value) const
나눗셈 연산자
Definition TLine.h:4494
FLImaging::Base::TLine::TLine
TLine(const TPoint< uint16_t > *pTp0, const TPoint< uint16_t > *pTp1)
초기화 생성자
Definition TLine.h:608
FLImaging::Base::TLine::operator/
TLine< T > operator/(const TPoint< double > &tp) const
나눗셈 연산자
Definition TLine.h:4634
FLImaging::Base::TLine::Set
void Set(float x0, float y0, float x1, float y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2206
FLImaging::Base::TLine::TLine
TLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1)
초기화 생성자
Definition TLine.h:978
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(int32_t value)
뺄셈 대입 연산자
Definition TLine.h:2876
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(float value)
직선의 모든 좌표에 동일한 값을 대입합니다.
Definition TLine.h:2284
FLImaging::Base::TLine::operator*
TLine< T > operator*(const TPoint< float > &tp) const
곱셈 연산자
Definition TLine.h:4338
FLImaging::Base::TLine::TLine
TLine(const TLine< int8_t > *pTl)
복사 생성자
Definition TLine.h:83
FLImaging::Base::TLine::operator-
TLine< T > operator-(float value) const
뺄셈 연산자
Definition TLine.h:3972
FLImaging::Base::TLine::TLine
TLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
초기화 생성자
Definition TLine.h:1024
FLImaging::Base::TLine::TLine
TLine(const TLine< uint16_t > *pTl)
복사 생성자
Definition TLine.h:194
FLImaging::Base::TLine::Set
void Set(const TPoint< float > *pTp0, const TPoint< float > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1943
FLImaging::Base::TLine::Set
void Set(int16_t x0, int16_t y0, int16_t x1, int16_t y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2068
FLImaging::Base::TLine< int8_t >::tpPoints
TPoint< int8_t > tpPoints[2]
Definition TLine.h:44
FLImaging::Base::TLine::operator-
TLine< T > operator-(const TPoint< float > &tp) const
뺄셈 연산자
Definition TLine.h:4066
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(double value)
덧셈 대입 연산자
Definition TLine.h:2679
FLImaging::Base::TLine::Set
void Set(const TPoint< uint64_t > *pTp0, const TPoint< uint64_t > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1894
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(const TLine< float > &tl)
나눗셈 대입 연산자
Definition TLine.h:3614
FLImaging::Base::TLine::Set
void Set(const TLine< int64_t > &tl)
직선을 설정합니다.
Definition TLine.h:1378
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(const TPoint< double > &tp)
덧셈 대입 연산자
Definition TLine.h:2771
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(const TPoint< double > &tp)
나눗셈 대입 연산자
Definition TLine.h:3551
FLImaging::Base::TLine::TLine
TLine(const TLine< int64_t > *pTl)
복사 생성자
Definition TLine.h:305
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(int64_t value)
곱셈 대입 연산자
Definition TLine.h:3157
FLImaging::Base::TLine::TLine
TLine(const TLine< int16_t > *pTl)
복사 생성자
Definition TLine.h:157
FLImaging::Base::TLine::operator!=
bool operator!=(const TLine< float > &tl) const
비교 연산자
Definition TLine.h:2584
FLImaging::Base::TLine::operator+
TLine< T > operator+(const TLine< int64_t > &tl) const
덧셈 연산자
Definition TLine.h:3862
FLImaging::Base::TLine::operator/
TLine< T > operator/(float value) const
나눗셈 연산자
Definition TLine.h:4516
FLImaging::Base::TLine::operator-
TLine< T > operator-(const TLine< double > &tl) const
뺄셈 연산자
Definition TLine.h:4178
FLImaging::Base::TLine::operator*
friend TLine< T > operator*(double value, const TLine< T > &tl)
곱셈 연산자
Definition TLine.h:5104
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(int32_t value)
직선의 모든 좌표에 동일한 값을 대입합니다.
Definition TLine.h:2248
FLImaging::Base::TLine::operator+
TLine< T > operator+(const TPoint< int32_t > &tp) const
덧셈 연산자
Definition TLine.h:3746
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(const TPoint< double > &tp)
곱셈 대입 연산자
Definition TLine.h:3291
FLImaging::Base::TLine::operator*
friend TLine< T > operator*(float value, const TLine< T > &tl)
곱셈 연산자
Definition TLine.h:5086
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(const TLine< int64_t > &tl)
뺄셈 대입 연산자
Definition TLine.h:3073
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(double value)
곱셈 대입 연산자
Definition TLine.h:3199
FLImaging::Base::TLine::TLine
TLine(const TPoint< int8_t > *pTp0, const TPoint< int8_t > *pTp1)
초기화 생성자
Definition TLine.h:461
FLImaging::Base::TLine::operator==
bool operator==(const TLine< int64_t > &tl) const
비교 연산자
Definition TLine.h:2504
FLImaging::Base::TLine::Set
void Set(const TPoint< uint8_t > *pTp0, const TPoint< uint8_t > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1600
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(const TLine< float > &tl)
덧셈 대입 연산자
Definition TLine.h:2834
FLImaging::Base::TLine::operator+
TLine< T > operator+(const TPoint< float > &tp) const
덧셈 연산자
Definition TLine.h:3794
FLImaging::Base::TLine::TLine
TLine(float x0, float y0, float x1, float y1)
초기화 생성자
Definition TLine.h:1116
FLImaging::Base::TLine::Set
void Set(const TPoint< uint64_t > &tp0, const TPoint< uint64_t > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1873
FLImaging::Base::TLine::Set
void Set(const TPoint< uint16_t > &tp0, const TPoint< uint16_t > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1677
FLImaging::Base::TLine::operator*
friend TLine< T > operator*(int32_t value, const TLine< T > &tl)
곱셈 연산자
Definition TLine.h:5050
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(const TPoint< int32_t > &tp)
곱셈 대입 연산자
Definition TLine.h:3222
FLImaging::Base::TLine::operator/
TLine< T > operator/(double value) const
나눗셈 연산자
Definition TLine.h:4538
FLImaging::Base::TLine::Set
void Set(const TLine< float > *pTl)
직선을 설정합니다.
Definition TLine.h:1469
FLImaging::Base::TLine::operator+
friend TLine< T > operator+(const TPoint< int32_t > &tp, const TLine< T > &tl)
덧셈 연산자
Definition TLine.h:4820
FLImaging::Base::TLine::operator/
TLine< T > operator/(const TLine< float > &tl) const
나눗셈 연산자
Definition TLine.h:4700
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(const TPoint< int64_t > &tp)
직선의 모든 정점에 동일한 점 값을 대입합니다.
Definition TLine.h:2343
FLImaging::Base::TLine::operator*
TLine< T > operator*(const TLine< int32_t > &tl) const
곱셈 연산자
Definition TLine.h:4384
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(const TPoint< int32_t > &tp)
덧셈 대입 연산자
Definition TLine.h:2702
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(const TPoint< int32_t > &tp)
뺄셈 대입 연산자
Definition TLine.h:2962
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(const TLine< int64_t > &tl)
덧셈 대입 연산자
Definition TLine.h:2813
FLImaging::Base::TLine::TLine
TLine(const TPoint< uint8_t > *pTp0, const TPoint< uint8_t > *pTp1)
초기화 생성자
Definition TLine.h:510
FLImaging::Base::TLine::operator-
TLine< T > operator-(const TPoint< double > &tp) const
뺄셈 연산자
Definition TLine.h:4090
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(double value)
뺄셈 대입 연산자
Definition TLine.h:2939
FLImaging::Base::TLine::operator+
TLine< T > operator+(const TPoint< int64_t > &tp) const
덧셈 연산자
Definition TLine.h:3770
FLImaging::Base::TLine::Set
void Set(const TPoint< uint32_t > *pTp0, const TPoint< uint32_t > *pTp1)
직선의 정점을 설정합니다.
Definition TLine.h:1796
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(const TPoint< double > &tp)
뺄셈 대입 연산자
Definition TLine.h:3031
FLImaging::Base::TLine::operator*
TLine< T > operator*(const TLine< double > &tl) const
곱셈 연산자
Definition TLine.h:4450
FLImaging::Base::TLine::Set
void Set(const TLine< uint8_t > &tl)
직선을 설정합니다.
Definition TLine.h:1193
FLImaging::Base::TLine::operator*
friend TLine< T > operator*(const TPoint< int32_t > &tp, const TLine< T > &tl)
곱셈 연산자
Definition TLine.h:5124
FLImaging::Base::TLine::TLine
TLine(const TPoint< uint16_t > &tp0, const TPoint< uint16_t > &tp1)
초기화 생성자
Definition TLine.h:587
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(const TLine< int32_t > &tl)
곱셈 대입 연산자
Definition TLine.h:3312
FLImaging::Base::TLine::operator-
friend TLine< T > operator-(const TPoint< int32_t > &tp, const TLine< T > &tl)
뺄셈 연산자
Definition TLine.h:4972
FLImaging::Base::TLine::operator-
TLine< T > operator-(double value) const
뺄셈 연산자
Definition TLine.h:3994
FLImaging::Base::TLine::TLine
TLine(const TLine< double > *pTl)
복사 생성자
Definition TLine.h:416
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(const TPoint< int32_t > &tp)
나눗셈 대입 연산자
Definition TLine.h:3482
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(const TLine< int64_t > &tl)
곱셈 대입 연산자
Definition TLine.h:3333
FLImaging::Base::TLine::TLine
TLine(const TPoint< uint32_t > *pTp0, const TPoint< uint32_t > *pTp1)
초기화 생성자
Definition TLine.h:706
FLImaging::Base::TLine::Set
void Set(uint64_t x0, uint64_t y0, uint64_t x1, uint64_t y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2183
FLImaging::Base::TLine::operator-
TLine< T > operator-(const TLine< int32_t > &tl) const
뺄셈 연산자
Definition TLine.h:4112
FLImaging::Base::TLine::operator-
friend TLine< T > operator-(float value, const TLine< T > &tl)
뺄셈 연산자
Definition TLine.h:4934
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(const TPoint< float > &tp)
덧셈 대입 연산자
Definition TLine.h:2748
FLImaging::Base::TLine::Set
void Set(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
직선의 좌표를 설정합니다.
Definition TLine.h:2114
FLImaging::Base::TLine::TLine
TLine(double x0, double y0, double x1, double y1)
초기화 생성자
Definition TLine.h:1139
FLImaging::Base::TLine::operator+
friend TLine< T > operator+(int32_t value, const TLine< T > &tl)
덧셈 연산자
Definition TLine.h:4746
FLImaging::Base::TLine::TLine
TLine(const TLine< int16_t > &tl)
복사 생성자
Definition TLine.h:140
FLImaging::Base::TLine::Set
void Set(const TLine< int16_t > *pTl)
직선을 설정합니다.
Definition TLine.h:1247
FLImaging::Base::TLine::operator+
TLine< T > operator+(const TLine< float > &tl) const
덧셈 연산자
Definition TLine.h:3884
FLImaging::Base::TLine::operator*
friend TLine< T > operator*(const TPoint< double > &tp, const TLine< T > &tl)
곱셈 연산자
Definition TLine.h:5184
FLImaging::Base::TLine::TLine
TLine(const TPoint< int64_t > *pTp0, const TPoint< int64_t > *pTp1)
초기화 생성자
Definition TLine.h:755
FLImaging::Base::TLine::operator*
TLine< T > operator*(const TLine< float > &tl) const
곱셈 연산자
Definition TLine.h:4428
FLImaging::Base::TLine::Set
void Set(const TPoint< int8_t > &tp0, const TPoint< int8_t > &tp1)
직선의 정점을 설정합니다.
Definition TLine.h:1530
FLImaging::Base::TLine::operator-
friend TLine< T > operator-(int64_t value, const TLine< T > &tl)
뺄셈 연산자
Definition TLine.h:4916
FLImaging::Base::TLine::operator!=
bool operator!=(const TLine< double > &tl) const
비교 연산자
Definition TLine.h:2600
FLImaging::Base::TLine::operator/
TLine< T > operator/(const TLine< int64_t > &tl) const
나눗셈 연산자
Definition TLine.h:4678
FLImaging::Base::TLine::Set
void Set(const TLine< int16_t > &tl)
직선을 설정합니다.
Definition TLine.h:1230
FLImaging::Base::TLine::TLine
TLine(const TLine< uint16_t > &tl)
복사 생성자
Definition TLine.h:177
FLImaging::Base::TLine::operator*
friend TLine< T > operator*(const TPoint< float > &tp, const TLine< T > &tl)
곱셈 연산자
Definition TLine.h:5164
FLImaging::Base::TLine::operator*
TLine< T > operator*(double value) const
곱셈 연산자
Definition TLine.h:4266
FLImaging::Base::TLine::operator+=
const TLine< T > & operator+=(float value)
덧셈 대입 연산자
Definition TLine.h:2658
FLImaging::Base::TLine::operator*=
const TLine< T > & operator*=(const TLine< float > &tl)
곱셈 대입 연산자
Definition TLine.h:3354
FLImaging::Base::TLine::TLine
TLine(const TPoint< float > *pTp0, const TPoint< float > *pTp1)
초기화 생성자
Definition TLine.h:853
FLImaging::Base::TLine::operator*
TLine< T > operator*(int32_t value) const
곱셈 연산자
Definition TLine.h:4200
FLImaging::Base::TLine::TLine
TLine(const TPoint< uint32_t > &tp0, const TPoint< uint32_t > &tp1)
초기화 생성자
Definition TLine.h:685
FLImaging::Base::TLine::TLine
TLine(const TLine< int32_t > *pTl)
복사 생성자
Definition TLine.h:231
FLImaging::Base::TLine::TLine
TLine(const TLine< double > &tl)
복사 생성자
Definition TLine.h:399
FLImaging::Base::TLine::TLine
TLine(const TPoint< uint64_t > &tp0, const TPoint< uint64_t > &tp1)
초기화 생성자
Definition TLine.h:783
FLImaging::Base::TLine::operator=
const TLine< T > & operator=(int64_t value)
직선의 모든 좌표에 동일한 값을 대입합니다.
Definition TLine.h:2266
FLImaging::Base::TLine::operator-=
const TLine< T > & operator-=(int64_t value)
뺄셈 대입 연산자
Definition TLine.h:2897
FLImaging::Base::TLine::operator*
TLine< T > operator*(float value) const
곱셈 연산자
Definition TLine.h:4244
FLImaging::Base::TLine::operator/=
const TLine< T > & operator/=(int32_t value)
나눗셈 대입 연산자
Definition TLine.h:3396
FLImaging::Base::TPoint
점을 표현하는 간략화된 클래스
Definition TPoint.h:37
FLImaging::Base
Definition AESCryptography.h:18
생성시간 : , 프로젝트명 : FLImaging, 생성자 :  doxygen 1.17.0