QGIS API Documentation 3.29.0-Master (006c3c0232)
qgsunittypes.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsunittypes.cpp
3 --------------
4 begin : February 2016
5 copyright : (C) 2016 by Nyall Dawson
6 email : nyall dot dawson at gmail dot com
7 ***************************************************************************/
8/***************************************************************************
9 * *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 ***************************************************************************/
16
17#include "qgsunittypes.h"
18#include "qgis.h"
19
20/***************************************************************************
21 * This class is considered CRITICAL and any change MUST be accompanied with
22 * full unit tests in test_qgsunittypes.py.
23 * See details in QEP #17
24 ****************************************************************************/
25
27{
28 switch ( type )
29 {
30 case TypeDistance:
31 return QStringLiteral( "distance" );
32
33 case TypeArea:
34 return QStringLiteral( "area" );
35
36 case TypeVolume:
37 return QStringLiteral( "volume" );
38
39 case TypeTemporal:
40 return QStringLiteral( "temporal" );
41
42 case TypeUnknown:
43 return QStringLiteral( "<unknown>" );
44
45 }
46 return QString();
47}
48
49QgsUnitTypes::UnitType QgsUnitTypes::decodeUnitType( const QString &string, bool *ok )
50{
51 const QString normalized = string.trimmed().toLower();
52
53 if ( ok )
54 *ok = true;
55
56 if ( normalized == encodeUnitType( TypeDistance ) )
57 return TypeDistance;
58 if ( normalized == encodeUnitType( TypeArea ) )
59 return TypeArea;
60 if ( normalized == encodeUnitType( TypeVolume ) )
61 return TypeVolume;
62 if ( normalized == encodeUnitType( TypeTemporal ) )
63 return TypeTemporal;
64 if ( normalized == encodeUnitType( TypeUnknown ) )
65 return TypeUnknown;
66
67 if ( ok )
68 *ok = false;
69
70 return TypeUnknown;
71}
72
74{
75 switch ( unit )
76 {
77 case DistanceMeters:
78 case DistanceFeet:
80 case DistanceYards:
81 case DistanceMiles:
85 return Standard;
86
87 case DistanceDegrees:
88 return Geographic;
89
91 return UnknownType;
92 }
93 return UnknownType;
94}
95
97{
98 switch ( unit )
99 {
100 case AreaSquareMeters:
102 case AreaSquareFeet:
103 case AreaSquareYards:
104 case AreaSquareMiles:
105 case AreaHectares:
106 case AreaAcres:
110 return Standard;
111
113 return Geographic;
114
115 case AreaUnknownUnit:
116 return UnknownType;
117 }
118
119 return UnknownType;
120}
121
123{
124 switch ( unit )
125 {
126 case DistanceMeters:
127 return QStringLiteral( "meters" );
128
130 return QStringLiteral( "km" );
131
132 case DistanceFeet:
133 return QStringLiteral( "feet" );
134
135 case DistanceYards:
136 return QStringLiteral( "yd" );
137
138 case DistanceMiles:
139 return QStringLiteral( "mi" );
140
141 case DistanceDegrees:
142 return QStringLiteral( "degrees" );
143
145 return QStringLiteral( "<unknown>" );
146
148 return QStringLiteral( "nautical miles" );
149
151 return QStringLiteral( "cm" );
152
154 return QStringLiteral( "mm" );
155 }
156 return QString();
157}
158
159/***************************************************************************
160 * This class is considered CRITICAL and any change MUST be accompanied with
161 * full unit tests in test_qgsunittypes.py.
162 * See details in QEP #17
163 ****************************************************************************/
164
166{
167 const QString normalized = string.trimmed().toLower();
168
169 if ( ok )
170 *ok = true;
171
172 if ( normalized == encodeUnit( DistanceMeters ) )
173 return DistanceMeters;
174 if ( normalized == encodeUnit( DistanceFeet ) )
175 return DistanceFeet;
176 if ( normalized == encodeUnit( DistanceDegrees ) )
177 return DistanceDegrees;
178 if ( normalized == encodeUnit( DistanceNauticalMiles ) )
180 if ( normalized == encodeUnit( DistanceKilometers ) )
181 return DistanceKilometers;
182 if ( normalized == encodeUnit( DistanceYards ) )
183 return DistanceYards;
184 if ( normalized == encodeUnit( DistanceMiles ) )
185 return DistanceMiles;
186 if ( normalized == encodeUnit( DistanceCentimeters ) )
187 return DistanceCentimeters;
188 if ( normalized == encodeUnit( DistanceMillimeters ) )
189 return DistanceMillimeters;
190 if ( normalized == encodeUnit( DistanceUnknownUnit ) )
191 return DistanceUnknownUnit;
192
193 if ( ok )
194 *ok = false;
195
196 return DistanceUnknownUnit;
197}
198
200{
201 switch ( unit )
202 {
203 case DistanceMeters:
204 return QObject::tr( "meters", "distance" );
205
207 return QObject::tr( "kilometers", "distance" );
208
209 case DistanceFeet:
210 return QObject::tr( "feet", "distance" );
211
212 case DistanceYards:
213 return QObject::tr( "yards", "distance" );
214
215 case DistanceMiles:
216 return QObject::tr( "miles", "distance" );
217
218 case DistanceDegrees:
219 return QObject::tr( "degrees", "distance" );
220
222 return QObject::tr( "centimeters", "distance" );
223
225 return QObject::tr( "millimeters", "distance" );
226
228 return QObject::tr( "<unknown>", "distance" );
229
231 return QObject::tr( "nautical miles", "distance" );
232 }
233 return QString();
234}
235
237{
238 switch ( unit )
239 {
241 return QObject::tr( "mm", "render" );
242
243 case RenderMapUnits:
244 return QObject::tr( "map units", "render" );
245
246 case RenderPixels:
247 return QObject::tr( "px", "render" );
248
249 case RenderPercentage:
250 return QObject::tr( "%", "render" );
251
252 case RenderPoints:
253 return QObject::tr( "pt", "render" );
254
255 case RenderInches:
256 return QObject::tr( "in", "render" );
257
259 return QObject::tr( "unknown", "render" );
260
262 return QObject::tr( "m", "render" );
263
264 }
265
266 return QString();
267}
268
270{
271 switch ( unit )
272 {
273 case DistanceMeters:
274 return QObject::tr( "m", "distance" );
275
277 return QObject::tr( "km", "distance" );
278
279 case DistanceFeet:
280 return QObject::tr( "ft", "distance" );
281
282 case DistanceYards:
283 return QObject::tr( "yd", "distance" );
284
285 case DistanceMiles:
286 return QObject::tr( "mi", "distance" );
287
288 case DistanceDegrees:
289 return QObject::tr( "deg", "distance" );
290
292 return QObject::tr( "cm", "distance" );
293
295 return QObject::tr( "mm", "distance" );
296
298 return QString();
299
301 return QObject::tr( "NM", "distance" );
302 }
303 return QString();
304}
305
306/***************************************************************************
307 * This class is considered CRITICAL and any change MUST be accompanied with
308 * full unit tests in test_qgsunittypes.py.
309 * See details in QEP #17
310 ****************************************************************************/
311
313{
314 const QString normalized = string.trimmed().toLower();
315
316 if ( ok )
317 *ok = true;
318
319 if ( normalized == toString( DistanceMeters ) )
320 return DistanceMeters;
321 if ( normalized == toString( DistanceKilometers ) )
322 return DistanceKilometers;
323 if ( normalized == toString( DistanceFeet ) )
324 return DistanceFeet;
325 if ( normalized == toString( DistanceYards ) )
326 return DistanceYards;
327 if ( normalized == toString( DistanceMiles ) )
328 return DistanceMiles;
329 if ( normalized == toString( DistanceDegrees ) )
330 return DistanceDegrees;
331 if ( normalized == toString( DistanceCentimeters ) )
332 return DistanceCentimeters;
333 if ( normalized == toString( DistanceMillimeters ) )
334 return DistanceMillimeters;
335 if ( normalized == toString( DistanceNauticalMiles ) )
337 if ( normalized == toString( DistanceUnknownUnit ) )
338 return DistanceUnknownUnit;
339
340 if ( ok )
341 *ok = false;
342
343 return DistanceUnknownUnit;
344}
345
346/***************************************************************************
347 * This class is considered CRITICAL and any change MUST be accompanied with
348 * full unit tests in test_qgsunittypes.py.
349 * See details in QEP #17
350 ****************************************************************************/
351
353{
354#define DEGREE_TO_METER 111319.49079327358
355#define FEET_TO_METER 0.3048
356#define NMILE_TO_METER 1852.0
357#define KILOMETERS_TO_METER 1000.0
358#define CENTIMETERS_TO_METER 0.01
359#define MILLIMETERS_TO_METER 0.001
360#define YARDS_TO_METER 0.9144
361#define YARDS_TO_FEET 3.0
362#define MILES_TO_METER 1609.344
363
364 // Calculate the conversion factor between the specified units
365 switch ( fromUnit )
366 {
367 case DistanceMeters:
368 {
369 switch ( toUnit )
370 {
371 case DistanceMeters:
372 return 1.0;
374 return 1.0 / KILOMETERS_TO_METER;
376 return 1.0 / MILLIMETERS_TO_METER;
378 return 1.0 / CENTIMETERS_TO_METER;
379 case DistanceFeet:
380 return 1.0 / FEET_TO_METER;
381 case DistanceYards:
382 return 1.0 / YARDS_TO_METER;
383 case DistanceMiles:
384 return 1.0 / MILES_TO_METER;
385 case DistanceDegrees:
386 return 1.0 / DEGREE_TO_METER;
388 return 1.0 / NMILE_TO_METER;
390 break;
391 }
392
393 break;
394 }
396 {
397 switch ( toUnit )
398 {
399 case DistanceMeters:
400 return KILOMETERS_TO_METER;
402 return 1.0;
407 case DistanceFeet:
409 case DistanceYards:
411 case DistanceMiles:
413 case DistanceDegrees:
418 break;
419 }
420
421 break;
422 }
423 case DistanceFeet:
424 {
425 switch ( toUnit )
426 {
427 case DistanceMeters:
428 return FEET_TO_METER;
435 case DistanceFeet:
436 return 1.0;
437 case DistanceYards:
438 return 1.0 / YARDS_TO_FEET;
439 case DistanceMiles:
441 case DistanceDegrees:
446 break;
447 }
448
449 break;
450 }
451 case DistanceYards:
452 {
453 switch ( toUnit )
454 {
455 case DistanceMeters:
456 return YARDS_TO_METER;
463 case DistanceFeet:
464 return YARDS_TO_FEET;
465 case DistanceYards:
466 return 1.0;
467 case DistanceMiles:
469 case DistanceDegrees:
474 break;
475 }
476
477 break;
478 }
479 case DistanceMiles:
480 {
481 switch ( toUnit )
482 {
483 case DistanceMeters:
484 return MILES_TO_METER;
491 case DistanceFeet:
493 case DistanceYards:
495 case DistanceMiles:
496 return 1.0;
497 case DistanceDegrees:
502 break;
503 }
504
505 break;
506 }
507 case DistanceDegrees:
508 {
509 switch ( toUnit )
510 {
511 case DistanceMeters:
512 return DEGREE_TO_METER;
519 case DistanceFeet:
521 case DistanceYards:
523 case DistanceMiles:
525 case DistanceDegrees:
526 return 1.0;
530 break;
531 }
532
533 break;
534 }
536 {
537 switch ( toUnit )
538 {
539 case DistanceMeters:
540 return NMILE_TO_METER;
547 case DistanceFeet:
549 case DistanceYards:
551 case DistanceMiles:
553 case DistanceDegrees:
556 return 1.0;
558 break;
559 }
560
561 break;
562 }
564 {
565 switch ( toUnit )
566 {
567 case DistanceMeters:
572 return 1.0;
575 case DistanceFeet:
577 case DistanceYards:
579 case DistanceMiles:
581 case DistanceDegrees:
586 break;
587 }
588
589 break;
590 }
592 {
593 switch ( toUnit )
594 {
595 case DistanceMeters:
602 return 1.0;
603 case DistanceFeet:
605 case DistanceYards:
607 case DistanceMiles:
609 case DistanceDegrees:
614 break;
615 }
616
617 break;
618 }
620 break;
621 }
622 return 1.0;
623}
624
626{
627 switch ( unit )
628 {
629 case AreaSquareMeters:
630 return QStringLiteral( "m2" );
632 return QStringLiteral( "km2" );
633 case AreaSquareFeet:
634 return QStringLiteral( "ft2" );
635 case AreaSquareYards:
636 return QStringLiteral( "y2" );
637 case AreaSquareMiles:
638 return QStringLiteral( "mi2" );
639 case AreaHectares:
640 return QStringLiteral( "ha" );
641 case AreaAcres:
642 return QStringLiteral( "ac" );
644 return QStringLiteral( "nm2" );
646 return QStringLiteral( "deg2" );
648 return QStringLiteral( "cm2" );
650 return QStringLiteral( "mm2" );
651 case AreaUnknownUnit:
652 return QStringLiteral( "<unknown>" );
653 }
654 return QString();
655}
656
657QgsUnitTypes::AreaUnit QgsUnitTypes::decodeAreaUnit( const QString &string, bool *ok )
658{
659 const QString normalized = string.trimmed().toLower();
660
661 if ( ok )
662 *ok = true;
663
664 if ( normalized == encodeUnit( AreaSquareMeters ) )
665 return AreaSquareMeters;
666 if ( normalized == encodeUnit( AreaSquareKilometers ) )
668 if ( normalized == encodeUnit( AreaSquareFeet ) )
669 return AreaSquareFeet;
670 if ( normalized == encodeUnit( AreaSquareYards ) )
671 return AreaSquareYards;
672 if ( normalized == encodeUnit( AreaSquareMiles ) )
673 return AreaSquareMiles;
674 if ( normalized == encodeUnit( AreaHectares ) )
675 return AreaHectares;
676 if ( normalized == encodeUnit( AreaAcres ) )
677 return AreaAcres;
678 if ( normalized == encodeUnit( AreaSquareNauticalMiles ) )
680 if ( normalized == encodeUnit( AreaSquareDegrees ) )
681 return AreaSquareDegrees;
682 if ( normalized == encodeUnit( AreaSquareCentimeters ) )
684 if ( normalized == encodeUnit( AreaSquareMillimeters ) )
686 if ( normalized == encodeUnit( AreaUnknownUnit ) )
687 return AreaUnknownUnit;
688
689 if ( ok )
690 *ok = false;
691
692 return AreaUnknownUnit;
693}
694
696{
697 switch ( unit )
698 {
699 case AreaSquareMeters:
700 return QObject::tr( "square meters", "area" );
702 return QObject::tr( "square kilometers", "area" );
703 case AreaSquareFeet:
704 return QObject::tr( "square feet", "area" );
705 case AreaSquareYards:
706 return QObject::tr( "square yards", "area" );
707 case AreaSquareMiles:
708 return QObject::tr( "square miles", "area" );
709 case AreaHectares:
710 return QObject::tr( "hectares", "area" );
711 case AreaAcres:
712 return QObject::tr( "acres", "area" );
714 return QObject::tr( "square nautical miles", "area" );
716 return QObject::tr( "square degrees", "area" );
718 return QObject::tr( "square millimeters", "area" );
720 return QObject::tr( "square centimeters", "area" );
721 case AreaUnknownUnit:
722 return QObject::tr( "<unknown>", "area" );
723 }
724 return QString();
725}
726
728{
729 switch ( unit )
730 {
731 case AreaSquareMeters:
732 return QObject::tr( "m²", "area" );
734 return QObject::tr( "km²", "area" );
735 case AreaSquareFeet:
736 return QObject::tr( "ft²", "area" );
737 case AreaSquareYards:
738 return QObject::tr( "yd²", "area" );
739 case AreaSquareMiles:
740 return QObject::tr( "mi²", "area" );
741 case AreaHectares:
742 return QObject::tr( "ha", "area" );
743 case AreaAcres:
744 return QObject::tr( "ac", "area" );
746 return QObject::tr( "NM²", "area" );
748 return QObject::tr( "deg²", "area" );
750 return QObject::tr( "cm²", "area" );
752 return QObject::tr( "mm²", "area" );
753 case AreaUnknownUnit:
754 return QString();
755 }
756 return QString();
757}
758
760{
761 const QString normalized = string.trimmed().toLower();
762
763 if ( ok )
764 *ok = true;
765
766 if ( normalized == toString( AreaSquareMeters ) )
767 return AreaSquareMeters;
768 if ( normalized == toString( AreaSquareKilometers ) )
770 if ( normalized == toString( AreaSquareFeet ) )
771 return AreaSquareFeet;
772 if ( normalized == toString( AreaSquareYards ) )
773 return AreaSquareYards;
774 if ( normalized == toString( AreaSquareMiles ) )
775 return AreaSquareMiles;
776 if ( normalized == toString( AreaHectares ) )
777 return AreaHectares;
778 if ( normalized == toString( AreaAcres ) )
779 return AreaAcres;
780 if ( normalized == toString( AreaSquareNauticalMiles ) )
782 if ( normalized == toString( AreaSquareDegrees ) )
783 return AreaSquareDegrees;
784 if ( normalized == toString( AreaSquareMillimeters ) )
786 if ( normalized == toString( AreaSquareCentimeters ) )
788 if ( normalized == toString( AreaUnknownUnit ) )
789 return AreaUnknownUnit;
790 if ( ok )
791 *ok = false;
792
793 return AreaUnknownUnit;
794}
795
797{
798#define KM2_TO_M2 1000000.0
799#define CM2_TO_M2 0.0001
800#define MM2_TO_M2 0.000001
801#define FT2_TO_M2 0.09290304
802#define YD2_TO_M2 0.83612736
803#define MI2_TO_M2 2589988.110336
804#define HA_TO_M2 10000.0
805#define AC_TO_FT2 43560.0
806#define DEG2_TO_M2 12392029030.5
807#define NM2_TO_M2 3429904.0
808
809 // Calculate the conversion factor between the specified units
810 switch ( fromUnit )
811 {
812 case AreaSquareMeters:
813 {
814 switch ( toUnit )
815 {
816 case AreaSquareMeters:
817 return 1.0;
819 return 1.0 / KM2_TO_M2;
820 case AreaSquareFeet:
821 return 1.0 / FT2_TO_M2;
822 case AreaSquareYards:
823 return 1.0 / YD2_TO_M2;
824 case AreaSquareMiles:
825 return 1.0 / MI2_TO_M2;
826 case AreaHectares:
827 return 1.0 / HA_TO_M2;
828 case AreaAcres:
829 return 1.0 / AC_TO_FT2 / FT2_TO_M2;
831 return 1.0 / NM2_TO_M2;
833 return 1.0 / DEG2_TO_M2;
835 return 1.0 / CM2_TO_M2;
837 return 1.0 / MM2_TO_M2;
838 case AreaUnknownUnit:
839 break;
840 }
841
842 break;
843 }
845 {
846 switch ( toUnit )
847 {
848 case AreaSquareMeters:
849 return KM2_TO_M2;
851 return 1.0;
852 case AreaSquareFeet:
853 return KM2_TO_M2 / FT2_TO_M2;
854 case AreaSquareYards:
855 return KM2_TO_M2 / YD2_TO_M2;
856 case AreaSquareMiles:
857 return KM2_TO_M2 / MI2_TO_M2;
858 case AreaHectares:
859 return KM2_TO_M2 / HA_TO_M2;
860 case AreaAcres:
861 return KM2_TO_M2 / AC_TO_FT2 / FT2_TO_M2;
863 return KM2_TO_M2 / NM2_TO_M2;
865 return KM2_TO_M2 / DEG2_TO_M2;
867 return KM2_TO_M2 / CM2_TO_M2;
869 return KM2_TO_M2 / MM2_TO_M2;
870 case AreaUnknownUnit:
871 break;
872 }
873
874 break;
875 }
876 case AreaSquareFeet:
877 {
878 switch ( toUnit )
879 {
880 case AreaSquareMeters:
881 return FT2_TO_M2;
883 return FT2_TO_M2 / KM2_TO_M2;
884 case AreaSquareFeet:
885 return 1.0;
886 case AreaSquareYards:
887 return FT2_TO_M2 / YD2_TO_M2;
888 case AreaSquareMiles:
889 return FT2_TO_M2 / MI2_TO_M2;
890 case AreaHectares:
891 return FT2_TO_M2 / HA_TO_M2;
892 case AreaAcres:
893 return 1.0 / AC_TO_FT2;
895 return FT2_TO_M2 / NM2_TO_M2;
897 return FT2_TO_M2 / DEG2_TO_M2;
899 return FT2_TO_M2 / CM2_TO_M2;
901 return FT2_TO_M2 / MM2_TO_M2;
902 case AreaUnknownUnit:
903 break;
904 }
905
906 break;
907 }
908
909 case AreaSquareYards:
910 {
911 switch ( toUnit )
912 {
913 case AreaSquareMeters:
914 return YD2_TO_M2;
916 return YD2_TO_M2 / KM2_TO_M2;
917 case AreaSquareFeet:
918 return YD2_TO_M2 / FT2_TO_M2;
919 case AreaSquareYards:
920 return 1.0;
921 case AreaSquareMiles:
922 return YD2_TO_M2 / MI2_TO_M2;
923 case AreaHectares:
924 return YD2_TO_M2 / HA_TO_M2;
925 case AreaAcres:
926 return YD2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
928 return YD2_TO_M2 / NM2_TO_M2;
930 return YD2_TO_M2 / DEG2_TO_M2;
932 return YD2_TO_M2 / CM2_TO_M2;
934 return YD2_TO_M2 / MM2_TO_M2;
935 case AreaUnknownUnit:
936 break;
937 }
938 break;
939 }
940
941 case AreaSquareMiles:
942 {
943 switch ( toUnit )
944 {
945 case AreaSquareMeters:
946 return MI2_TO_M2;
948 return MI2_TO_M2 / KM2_TO_M2;
949 case AreaSquareFeet:
950 return MI2_TO_M2 / FT2_TO_M2;
951 case AreaSquareYards:
952 return MI2_TO_M2 / YD2_TO_M2;
953 case AreaSquareMiles:
954 return 1.0;
955 case AreaHectares:
956 return MI2_TO_M2 / HA_TO_M2;
957 case AreaAcres:
958 return MI2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
960 return MI2_TO_M2 / NM2_TO_M2;
962 return MI2_TO_M2 / DEG2_TO_M2;
964 return MI2_TO_M2 / CM2_TO_M2;
966 return MI2_TO_M2 / MM2_TO_M2;
967 case AreaUnknownUnit:
968 break;
969 }
970
971 break;
972 }
973
974 case AreaHectares:
975 {
976 switch ( toUnit )
977 {
978 case AreaSquareMeters:
979 return HA_TO_M2;
981 return HA_TO_M2 / KM2_TO_M2;
982 case AreaSquareFeet:
983 return HA_TO_M2 / FT2_TO_M2;
984 case AreaSquareYards:
985 return HA_TO_M2 / YD2_TO_M2;
986 case AreaSquareMiles:
987 return HA_TO_M2 / MI2_TO_M2;
988 case AreaHectares:
989 return 1.0;
990 case AreaAcres:
991 return HA_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
993 return HA_TO_M2 / NM2_TO_M2;
995 return HA_TO_M2 / DEG2_TO_M2;
997 return HA_TO_M2 / CM2_TO_M2;
999 return HA_TO_M2 / MM2_TO_M2;
1000 case AreaUnknownUnit:
1001 break;
1002 }
1003
1004 break;
1005 }
1006
1007 case AreaAcres:
1008 {
1009 switch ( toUnit )
1010 {
1011 case AreaSquareMeters:
1012 return AC_TO_FT2 * FT2_TO_M2;
1014 return AC_TO_FT2 * FT2_TO_M2 / KM2_TO_M2;
1015 case AreaSquareFeet:
1016 return AC_TO_FT2;
1017 case AreaSquareYards:
1018 return AC_TO_FT2 * FT2_TO_M2 / YD2_TO_M2;
1019 case AreaSquareMiles:
1020 return AC_TO_FT2 * FT2_TO_M2 / MI2_TO_M2;
1021 case AreaHectares:
1022 return AC_TO_FT2 * FT2_TO_M2 / HA_TO_M2;
1023 case AreaAcres:
1024 return 1.0;
1026 return AC_TO_FT2 * FT2_TO_M2 / NM2_TO_M2;
1027 case AreaSquareDegrees:
1028 return AC_TO_FT2 * FT2_TO_M2 / DEG2_TO_M2;
1030 return AC_TO_FT2 * FT2_TO_M2 / CM2_TO_M2;
1032 return AC_TO_FT2 * FT2_TO_M2 / MM2_TO_M2;
1033 case AreaUnknownUnit:
1034 break;
1035 }
1036
1037 break;
1038 }
1039
1041 {
1042 switch ( toUnit )
1043 {
1044 case AreaSquareMeters:
1045 return NM2_TO_M2;
1047 return NM2_TO_M2 / KM2_TO_M2;
1048 case AreaSquareFeet:
1049 return NM2_TO_M2 / FT2_TO_M2;
1050 case AreaSquareYards:
1051 return NM2_TO_M2 / YD2_TO_M2;
1052 case AreaSquareMiles:
1053 return NM2_TO_M2 / MI2_TO_M2;
1054 case AreaHectares:
1055 return NM2_TO_M2 / HA_TO_M2;
1056 case AreaAcres:
1057 return NM2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
1059 return 1.0;
1060 case AreaSquareDegrees:
1061 return NM2_TO_M2 / DEG2_TO_M2;
1063 return NM2_TO_M2 / CM2_TO_M2;
1065 return NM2_TO_M2 / MM2_TO_M2;
1066 case AreaUnknownUnit:
1067 break;
1068 }
1069
1070 break;
1071 }
1072
1073 case AreaSquareDegrees:
1074 {
1075 switch ( toUnit )
1076 {
1077 case AreaSquareMeters:
1078 return DEG2_TO_M2;
1080 return DEG2_TO_M2 / KM2_TO_M2;
1081 case AreaSquareFeet:
1082 return DEG2_TO_M2 / FT2_TO_M2;
1083 case AreaSquareYards:
1084 return DEG2_TO_M2 / YD2_TO_M2;
1085 case AreaSquareMiles:
1086 return DEG2_TO_M2 / MI2_TO_M2;
1087 case AreaHectares:
1088 return DEG2_TO_M2 / HA_TO_M2;
1089 case AreaAcres:
1090 return DEG2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
1092 return DEG2_TO_M2 / NM2_TO_M2;
1093 case AreaSquareDegrees:
1094 return 1.0;
1096 return DEG2_TO_M2 / CM2_TO_M2;
1098 return DEG2_TO_M2 / MM2_TO_M2;
1099 case AreaUnknownUnit:
1100 break;
1101 }
1102
1103 break;
1104 }
1105
1107 {
1108 switch ( toUnit )
1109 {
1110 case AreaSquareMeters:
1111 return MM2_TO_M2;
1113 return MM2_TO_M2 / KM2_TO_M2;
1114 case AreaSquareFeet:
1115 return MM2_TO_M2 / FT2_TO_M2;
1116 case AreaSquareYards:
1117 return MM2_TO_M2 / YD2_TO_M2;
1118 case AreaSquareMiles:
1119 return MM2_TO_M2 / MI2_TO_M2;
1120 case AreaHectares:
1121 return MM2_TO_M2 / HA_TO_M2;
1122 case AreaAcres:
1123 return MM2_TO_M2 / AC_TO_FT2 / FT2_TO_M2;
1125 return MM2_TO_M2 / NM2_TO_M2;
1126 case AreaSquareDegrees:
1127 return MM2_TO_M2 / DEG2_TO_M2;
1129 return MM2_TO_M2 / CM2_TO_M2;
1131 return 1.0;
1132 case AreaUnknownUnit:
1133 break;
1134 }
1135
1136 break;
1137 }
1139 {
1140 switch ( toUnit )
1141 {
1142 case AreaSquareMeters:
1143 return CM2_TO_M2;
1145 return CM2_TO_M2 / KM2_TO_M2;
1146 case AreaSquareFeet:
1147 return CM2_TO_M2 / FT2_TO_M2;
1148 case AreaSquareYards:
1149 return CM2_TO_M2 / YD2_TO_M2;
1150 case AreaSquareMiles:
1151 return CM2_TO_M2 / MI2_TO_M2;
1152 case AreaHectares:
1153 return CM2_TO_M2 / HA_TO_M2;
1154 case AreaAcres:
1155 return CM2_TO_M2 / AC_TO_FT2 / FT2_TO_M2;
1157 return CM2_TO_M2 / NM2_TO_M2;
1158 case AreaSquareDegrees:
1159 return CM2_TO_M2 / DEG2_TO_M2;
1161 return 1.0;
1163 return CM2_TO_M2 / MM2_TO_M2;
1164 case AreaUnknownUnit:
1165 break;
1166 }
1167
1168 break;
1169 }
1170 case AreaUnknownUnit:
1171 break;
1172 }
1173 return 1.0;
1174}
1175
1177{
1178 switch ( distanceUnit )
1179 {
1180 case DistanceMeters:
1181 return AreaSquareMeters;
1182
1183 case DistanceKilometers:
1184 return AreaSquareKilometers;
1185
1187 return AreaSquareCentimeters;
1188
1190 return AreaSquareMillimeters;
1191
1192 case DistanceFeet:
1193 return AreaSquareFeet;
1194
1195 case DistanceYards:
1196 return AreaSquareYards;
1197
1198 case DistanceMiles:
1199 return AreaSquareMiles;
1200
1201 case DistanceDegrees:
1202 return AreaSquareDegrees;
1203
1205 return AreaUnknownUnit;
1206
1209 }
1210
1211 return AreaUnknownUnit;
1212}
1213
1215{
1216 switch ( areaUnit )
1217 {
1218 case AreaSquareMeters:
1219 case AreaHectares:
1220 return DistanceMeters;
1221
1223 return DistanceKilometers;
1224
1226 return DistanceCentimeters;
1227
1229 return DistanceMillimeters;
1230
1231 case AreaSquareFeet:
1232 return DistanceFeet;
1233
1234 case AreaSquareYards:
1235 case AreaAcres:
1236 return DistanceYards;
1237
1238 case AreaSquareMiles:
1239 return DistanceMiles;
1240
1241 case AreaSquareDegrees:
1242 return DistanceDegrees;
1243
1244 case AreaUnknownUnit:
1245 return DistanceUnknownUnit;
1246
1248 return DistanceNauticalMiles;
1249 }
1250
1251 return DistanceUnknownUnit;
1252}
1253
1255{
1256 switch ( unit )
1257 {
1258 case TemporalSeconds:
1259 return QStringLiteral( "s" );
1261 return QStringLiteral( "ms" );
1262 case TemporalMinutes:
1263 return QStringLiteral( "min" );
1264 case TemporalHours:
1265 return QStringLiteral( "h" );
1266 case TemporalDays:
1267 return QStringLiteral( "d" );
1268 case TemporalWeeks:
1269 return QStringLiteral( "wk" );
1270 case TemporalMonths:
1271 return QStringLiteral( "mon" );
1272 case TemporalYears:
1273 return QStringLiteral( "y" );
1274 case TemporalDecades:
1275 return QStringLiteral( "dec" );
1276 case TemporalCenturies:
1277 return QStringLiteral( "c" );
1279 return QStringLiteral( "xxx" );
1281 return QStringLiteral( "<unknown>" );
1282 }
1283 return QString();
1284}
1285
1287{
1288 const QString normalized = string.trimmed().toLower();
1289
1290 if ( ok )
1291 *ok = true;
1292
1293 if ( normalized == encodeUnit( TemporalSeconds ) )
1294 return TemporalSeconds;
1295 if ( normalized == encodeUnit( TemporalMilliseconds ) )
1296 return TemporalMilliseconds;
1297 if ( normalized == encodeUnit( TemporalMinutes ) )
1298 return TemporalMinutes;
1299 if ( normalized == encodeUnit( TemporalHours ) )
1300 return TemporalHours;
1301 if ( normalized == encodeUnit( TemporalDays ) )
1302 return TemporalDays;
1303 if ( normalized == encodeUnit( TemporalWeeks ) )
1304 return TemporalWeeks;
1305 if ( normalized == encodeUnit( TemporalMonths ) )
1306 return TemporalMonths;
1307 if ( normalized == encodeUnit( TemporalYears ) )
1308 return TemporalYears;
1309 if ( normalized == encodeUnit( TemporalDecades ) )
1310 return TemporalDecades;
1311 if ( normalized == encodeUnit( TemporalCenturies ) )
1312 return TemporalCenturies;
1313 if ( normalized == encodeUnit( TemporalIrregularStep ) )
1314 return TemporalIrregularStep;
1315 if ( normalized == encodeUnit( TemporalUnknownUnit ) )
1316 return TemporalUnknownUnit;
1317
1318 if ( ok )
1319 *ok = false;
1320
1321 return TemporalUnknownUnit;
1322}
1323
1325{
1326 switch ( unit )
1327 {
1328 case TemporalSeconds:
1329 return QObject::tr( "seconds", "temporal" );
1331 return QObject::tr( "milliseconds", "temporal" );
1332 case TemporalMinutes:
1333 return QObject::tr( "minutes", "temporal" );
1334 case TemporalHours:
1335 return QObject::tr( "hours", "temporal" );
1336 case TemporalDays:
1337 return QObject::tr( "days", "temporal" );
1338 case TemporalWeeks:
1339 return QObject::tr( "weeks", "temporal" );
1340 case TemporalMonths:
1341 return QObject::tr( "months", "temporal" );
1342 case TemporalYears:
1343 return QObject::tr( "years", "temporal" );
1344 case TemporalDecades:
1345 return QObject::tr( "decades", "temporal" );
1346 case TemporalCenturies:
1347 return QObject::tr( "centuries", "temporal" );
1349 return QObject::tr( "steps", "temporal" );
1351 return QObject::tr( "<unknown>", "temporal" );
1352 }
1353 return QString();
1354}
1355
1357{
1358 switch ( unit )
1359 {
1360 case TemporalSeconds:
1361 return QObject::tr( "s", "temporal" );
1363 return QObject::tr( "ms", "temporal" );
1364 case TemporalMinutes:
1365 return QObject::tr( "min", "temporal" );
1366 case TemporalHours:
1367 return QObject::tr( "h", "temporal" );
1368 case TemporalDays:
1369 return QObject::tr( "d", "temporal" );
1370 case TemporalWeeks:
1371 return QObject::tr( "wk", "temporal" );
1372 case TemporalMonths:
1373 return QObject::tr( "mon", "temporal" );
1374 case TemporalYears:
1375 return QObject::tr( "y", "temporal" );
1376 case TemporalDecades:
1377 return QObject::tr( "dec", "temporal" );
1378 case TemporalCenturies:
1379 return QObject::tr( "cen", "temporal" );
1381 return QObject::tr( "steps", "temporal" );
1383 return QObject::tr( "<unknown>", "temporal" );
1384 }
1385 return QString();
1386}
1387
1389{
1390 const QString normalized = string.trimmed().toLower();
1391
1392 if ( ok )
1393 *ok = true;
1394
1395 if ( normalized == toString( TemporalSeconds ) )
1396 return TemporalSeconds;
1397 if ( normalized == toString( TemporalMilliseconds ) )
1398 return TemporalMilliseconds;
1399 if ( normalized == toString( TemporalMinutes ) )
1400 return TemporalMinutes;
1401 if ( normalized == toString( TemporalHours ) )
1402 return TemporalHours;
1403 if ( normalized == toString( TemporalDays ) )
1404 return TemporalDays;
1405 if ( normalized == toString( TemporalWeeks ) )
1406 return TemporalWeeks;
1407 if ( normalized == toString( TemporalMonths ) )
1408 return TemporalMonths;
1409 if ( normalized == toString( TemporalYears ) )
1410 return TemporalYears;
1411 if ( normalized == toString( TemporalDecades ) )
1412 return TemporalDecades;
1413 if ( normalized == toString( TemporalCenturies ) )
1414 return TemporalCenturies;
1415 if ( normalized == toString( TemporalIrregularStep ) )
1416 return TemporalIrregularStep;
1417 if ( normalized == toString( TemporalUnknownUnit ) )
1418 return TemporalUnknownUnit;
1419
1420 if ( ok )
1421 *ok = false;
1422
1423 return TemporalUnknownUnit;
1424}
1425
1427{
1428 switch ( fromUnit )
1429 {
1430 case TemporalSeconds:
1431 {
1432 switch ( toUnit )
1433 {
1434 case TemporalSeconds:
1435 return 1.0;
1437 return 1000.0;
1438 case TemporalMinutes:
1439 return 1 / 60.0;
1440 case TemporalHours:
1441 return 1 / 3600.0;
1442 case TemporalDays:
1443 return 1 / 86400.0;
1444 case TemporalWeeks:
1445 return 1 / 604800.0;
1446 case TemporalMonths:
1447 return 1 / 2592000.0;
1448 case TemporalYears:
1449 return 1 / 31557600.0;
1450 case TemporalDecades:
1451 return 1 / 315576000.0;
1452 case TemporalCenturies:
1453 return 1 / 3155760000.0;
1456 return 1.0;
1457 }
1458 break;
1459 }
1461 {
1462 switch ( toUnit )
1463 {
1464 case TemporalSeconds:
1465 return 1 / 1000.0;
1467 return 1.0;
1468 case TemporalMinutes:
1469 return 1 / 60000.0;
1470 case TemporalHours:
1471 return 1 / 3600000.0;
1472 case TemporalDays:
1473 return 1 / 86400000.0;
1474 case TemporalWeeks:
1475 return 1 / 60480000.0;
1476 case TemporalMonths:
1477 return 1 / 259200000.0;
1478 case TemporalYears:
1479 return 1 / 3155760000.0;
1480 case TemporalDecades:
1481 return 1 / 31557600000.0;
1482 case TemporalCenturies:
1483 return 1 / 315576000000.0;
1486 return 1.0;
1487 }
1488 break;
1489 }
1490 case TemporalMinutes:
1491 {
1492 switch ( toUnit )
1493 {
1494 case TemporalSeconds:
1495 return 60.0;
1497 return 60000.0;
1498 case TemporalMinutes:
1499 return 1;
1500 case TemporalHours:
1501 return 1 / 60.0;
1502 case TemporalDays:
1503 return 1 / 1440.0;
1504 case TemporalWeeks:
1505 return 1 / 10080.0;
1506 case TemporalMonths:
1507 return 1 / 43200.0;
1508 case TemporalYears:
1509 return 1 / 525960.0;
1510 case TemporalDecades:
1511 return 1 / 5259600.0;
1512 case TemporalCenturies:
1513 return 1 / 52596000.0;
1516 return 1.0;
1517 }
1518 break;
1519 }
1520 case TemporalHours:
1521 {
1522 switch ( toUnit )
1523 {
1524 case TemporalSeconds:
1525 return 3600.0;
1527 return 3600000.0;
1528 case TemporalMinutes:
1529 return 60;
1530 case TemporalHours:
1531 return 1;
1532 case TemporalDays:
1533 return 1 / 24.0;
1534 case TemporalWeeks:
1535 return 1 / 168.0;
1536 case TemporalMonths:
1537 return 1 / 720.0;
1538 case TemporalYears:
1539 return 1 / 8766.0;
1540 case TemporalDecades:
1541 return 1 / 87660.0;
1542 case TemporalCenturies:
1543 return 1 / 876600.0;
1546 return 1.0;
1547 }
1548 break;
1549 }
1550 case TemporalDays:
1551 {
1552 switch ( toUnit )
1553 {
1554 case TemporalSeconds:
1555 return 86400.0;
1557 return 86400000.0;
1558 case TemporalMinutes:
1559 return 1440;
1560 case TemporalHours:
1561 return 24;
1562 case TemporalDays:
1563 return 1;
1564 case TemporalWeeks:
1565 return 1 / 7.0;
1566 case TemporalMonths:
1567 return 1 / 30.0;
1568 case TemporalYears:
1569 return 1 / 365.25;
1570 case TemporalDecades:
1571 return 1 / 3652.5;
1572 case TemporalCenturies:
1573 return 1 / 36525.0;
1576 return 1.0;
1577 }
1578 break;
1579 }
1580 case TemporalWeeks:
1581 {
1582 switch ( toUnit )
1583 {
1584 case TemporalSeconds:
1585 return 604800.0;
1587 return 604800000.0;
1588 case TemporalMinutes:
1589 return 10080;
1590 case TemporalHours:
1591 return 168;
1592 case TemporalDays:
1593 return 7;
1594 case TemporalWeeks:
1595 return 1;
1596 case TemporalMonths:
1597 return 7 / 30.0;
1598 case TemporalYears:
1599 return 7 / 365.25;
1600 case TemporalDecades:
1601 return 7 / 3652.5;
1602 case TemporalCenturies:
1603 return 7 / 36525.0;
1606 return 1.0;
1607 }
1608 break;
1609 }
1610 case TemporalMonths:
1611 {
1612 switch ( toUnit )
1613 {
1614 case TemporalSeconds:
1615 return 2592000.0;
1617 return 2592000000.0;
1618 case TemporalMinutes:
1619 return 43200;
1620 case TemporalHours:
1621 return 720;
1622 case TemporalDays:
1623 return 30;
1624 case TemporalWeeks:
1625 return 30 / 7.0;
1626 case TemporalMonths:
1627 return 1;
1628 case TemporalYears:
1629 return 30 / 365.25;
1630 case TemporalDecades:
1631 return 30 / 3652.5;
1632 case TemporalCenturies:
1633 return 30 / 36525.0;
1636 return 1.0;
1637 }
1638 break;
1639 }
1640 case TemporalYears:
1641 {
1642 switch ( toUnit )
1643 {
1644 case TemporalSeconds:
1645 return 31557600.0;
1647 return 31557600000.0;
1648 case TemporalMinutes:
1649 return 525960.0;
1650 case TemporalHours:
1651 return 8766.0;
1652 case TemporalDays:
1653 return 365.25;
1654 case TemporalWeeks:
1655 return 365.25 / 7.0;
1656 case TemporalMonths:
1657 return 365.25 / 30.0;
1658 case TemporalYears:
1659 return 1;
1660 case TemporalDecades:
1661 return 0.1;
1662 case TemporalCenturies:
1663 return 0.01;
1666 return 1.0;
1667 }
1668 break;
1669 }
1670 case TemporalDecades:
1671 {
1672 switch ( toUnit )
1673 {
1674 case TemporalSeconds:
1675 return 315576000.0;
1677 return 315576000000.0;
1678 case TemporalMinutes:
1679 return 5259600.0;
1680 case TemporalHours:
1681 return 87660.0;
1682 case TemporalDays:
1683 return 3652.5;
1684 case TemporalWeeks:
1685 return 3652.5 / 7.0;
1686 case TemporalMonths:
1687 return 3652.5 / 30.0;
1688 case TemporalYears:
1689 return 10;
1690 case TemporalDecades:
1691 return 1;
1692 case TemporalCenturies:
1693 return 0.1;
1696 return 1.0;
1697 }
1698 break;
1699 }
1700
1701 case TemporalCenturies:
1702 {
1703 switch ( toUnit )
1704 {
1705 case TemporalSeconds:
1706 return 3155760000.0;
1708 return 3155760000000.0;
1709 case TemporalMinutes:
1710 return 52596000.0;
1711 case TemporalHours:
1712 return 876600.0;
1713 case TemporalDays:
1714 return 36525;
1715 case TemporalWeeks:
1716 return 36525 / 7.0;
1717 case TemporalMonths:
1718 return 36525 / 30.0;
1719 case TemporalYears:
1720 return 100;
1721 case TemporalDecades:
1722 return 10;
1723 case TemporalCenturies:
1724 return 1;
1727 return 1.0;
1728 }
1729 break;
1730 }
1731
1734 {
1735 return 1.0;
1736 }
1737 }
1738 return 1.0;
1739}
1740
1742{
1743 const QString normalized = string.trimmed().toLower();
1744
1745 if ( ok )
1746 *ok = true;
1747
1748 if ( normalized == encodeUnit( VolumeCubicMeters ) )
1749 return VolumeCubicMeters;
1750 if ( normalized == encodeUnit( VolumeCubicFeet ) )
1751 return VolumeCubicFeet;
1752 if ( normalized == encodeUnit( VolumeCubicYards ) )
1753 return VolumeCubicYards;
1754 if ( normalized == encodeUnit( VolumeBarrel ) )
1755 return VolumeBarrel;
1756 if ( normalized == encodeUnit( VolumeCubicDecimeter ) )
1757 return VolumeCubicDecimeter;
1758 if ( normalized == encodeUnit( VolumeLiters ) )
1759 return VolumeLiters;
1760 if ( normalized == encodeUnit( VolumeGallonUS ) )
1761 return VolumeGallonUS;
1762 if ( normalized == encodeUnit( VolumeCubicInch ) )
1763 return VolumeCubicInch;
1764 if ( normalized == encodeUnit( VolumeCubicCentimeter ) )
1765 return VolumeCubicCentimeter;
1766 if ( normalized == encodeUnit( VolumeCubicDegrees ) )
1767 return VolumeCubicDegrees;
1768 if ( normalized == encodeUnit( VolumeUnknownUnit ) )
1769 return VolumeUnknownUnit;
1770
1771 if ( ok )
1772 *ok = false;
1773
1774 return VolumeUnknownUnit;
1775}
1776
1778{
1779 switch ( unit )
1780 {
1781 case VolumeCubicMeters:
1782 return QObject::tr( "cubic meters", "volume" );
1783 case VolumeCubicFeet:
1784 return QObject::tr( "cubic feet", "volume" );
1785 case VolumeCubicYards:
1786 return QObject::tr( "cubic yards", "volume" );
1787 case VolumeBarrel:
1788 return QObject::tr( "barrels", "volume" );
1790 return QObject::tr( "cubic decimeters", "volume" );
1791 case VolumeLiters:
1792 return QObject::tr( "liters", "volume" );
1793 case VolumeGallonUS:
1794 return QObject::tr( "gallons", "volume" );
1795 case VolumeCubicInch:
1796 return QObject::tr( "cubic inches", "volume" );
1798 return QObject::tr( "cubic centimeters", "volume" );
1799 case VolumeCubicDegrees:
1800 return QObject::tr( "cubic degrees", "volume" );
1801 case VolumeUnknownUnit:
1802 return QObject::tr( "<unknown>", "volume" );
1803 }
1804 return QString();
1805}
1806
1808{
1809 switch ( unit )
1810 {
1811 case VolumeCubicMeters:
1812 return QObject::tr( "m³", "volume" );
1813 case VolumeCubicFeet:
1814 return QObject::tr( "ft³", "volume" );
1815 case VolumeCubicYards:
1816 return QObject::tr( "yds³", "volume" );
1817 case VolumeBarrel:
1818 return QObject::tr( "bbl", "volume" );
1820 return QObject::tr( "dm³", "volume" );
1821 case VolumeLiters:
1822 return QObject::tr( "l", "volume" );
1823 case VolumeGallonUS:
1824 return QObject::tr( "gal", "volume" );
1825 case VolumeCubicInch:
1826 return QObject::tr( "in³", "volume" );
1828 return QObject::tr( "cm³", "volume" );
1829 case VolumeCubicDegrees:
1830 return QObject::tr( "deg³", "volume" );
1831 case VolumeUnknownUnit:
1832 return QObject::tr( "<unknown>", "volume" );
1833 }
1834 return QString();
1835
1836}
1837
1839{
1840 const QString normalized = string.trimmed().toLower();
1841
1842 if ( ok )
1843 *ok = true;
1844
1845 if ( normalized == toString( VolumeCubicMeters ) )
1846 return VolumeCubicMeters;
1847 if ( normalized == toString( VolumeCubicFeet ) )
1848 return VolumeCubicFeet;
1849 if ( normalized == toString( VolumeCubicYards ) )
1850 return VolumeCubicYards;
1851 if ( normalized == toString( VolumeBarrel ) )
1852 return VolumeBarrel;
1853 if ( normalized == toString( VolumeCubicDecimeter ) )
1854 return VolumeCubicDecimeter;
1855 if ( normalized == toString( VolumeLiters ) )
1856 return VolumeLiters;
1857 if ( normalized == toString( VolumeGallonUS ) )
1858 return VolumeGallonUS;
1859 if ( normalized == toString( VolumeCubicInch ) )
1860 return VolumeCubicInch;
1861 if ( normalized == toString( VolumeCubicCentimeter ) )
1862 return VolumeCubicCentimeter;
1863 if ( normalized == toString( VolumeCubicDegrees ) )
1864 return VolumeCubicDegrees;
1865 if ( normalized == toString( VolumeUnknownUnit ) )
1866 return VolumeUnknownUnit;
1867
1868 if ( ok )
1869 *ok = false;
1870
1871 return VolumeUnknownUnit;
1872}
1873
1874#define DEG2_TO_M3 1379474361572186.2
1876{
1877 switch ( fromUnit )
1878 {
1879 case VolumeCubicMeters:
1880 {
1881 switch ( toUnit )
1882 {
1883 case VolumeCubicMeters:
1884 return 1.0;
1885 case VolumeCubicFeet:
1886 return 35.314666572222;
1887 case VolumeCubicYards:
1888 return 1.307950613786;
1889 case VolumeBarrel:
1890 return 6.2898107438466;
1892 return 1000;
1893 case VolumeLiters:
1894 return 1000;
1895 case VolumeGallonUS:
1896 return 264.17205124156;
1897 case VolumeCubicInch:
1898 return 61023.7438368;
1900 return 1000000;
1901 case VolumeCubicDegrees:
1902 return 1 / DEG2_TO_M3; // basically meaningless!
1903 case VolumeUnknownUnit:
1904 return 1.0;
1905 }
1906 break;
1907 }
1908 case VolumeCubicFeet:
1909 {
1910 switch ( toUnit )
1911 {
1912 case VolumeCubicMeters:
1913 return 0.028316846592;
1914 case VolumeCubicFeet:
1915 return 1.0;
1916 case VolumeCubicYards:
1917 return 0.037037037;
1918 case VolumeBarrel:
1919 return 0.178107622;
1921 return 28.31685;
1922 case VolumeLiters:
1923 return 28.31685;
1924 case VolumeGallonUS:
1925 return 7.480519954;
1926 case VolumeCubicInch:
1927 return 1728.000629765;
1929 return 28316.85;
1930 case VolumeCubicDegrees:
1931 return 0.028316846592 / DEG2_TO_M3; // basically meaningless!
1932 case VolumeUnknownUnit:
1933 return 1.0;
1934 }
1935 break;
1936 }
1937 case VolumeCubicYards:
1938 {
1939 switch ( toUnit )
1940 {
1941 case VolumeCubicMeters:
1942 return 0.764554900;
1943 case VolumeCubicFeet:
1944 return 26.999998234;
1945 case VolumeCubicYards:
1946 return 1.0;
1947 case VolumeBarrel:
1948 return 4.808905491;
1950 return 764.5549;
1951 case VolumeLiters:
1952 return 764.5549;
1953 case VolumeGallonUS:
1954 return 201.974025549;
1955 case VolumeCubicInch:
1956 return 46656.013952472;
1958 return 764554.9;
1959 case VolumeCubicDegrees:
1960 return 0.764554900 / DEG2_TO_M3; // basically meaningless!
1961 case VolumeUnknownUnit:
1962 return 1.0;
1963 }
1964 break;
1965 }
1966 case VolumeBarrel:
1967 {
1968 switch ( toUnit )
1969 {
1970 case VolumeCubicMeters:
1971 return 0.158987300;
1972 case VolumeCubicFeet:
1973 return 5.614582837;
1974 case VolumeCubicYards:
1975 return 0.207947526;
1976 case VolumeBarrel:
1977 return 1.0;
1979 return 158.9873;
1980 case VolumeLiters:
1981 return 158.9873;
1982 case VolumeGallonUS:
1983 return 41.999998943;
1984 case VolumeCubicInch:
1985 return 9702.002677722;
1987 return 158987.3;
1988 case VolumeCubicDegrees:
1989 return 0.158987300 / DEG2_TO_M3; // basically meaningless!
1990 case VolumeUnknownUnit:
1991 return 1.0;
1992 }
1993 break;
1994 }
1996 case VolumeLiters:
1997 {
1998 switch ( toUnit )
1999 {
2000 case VolumeCubicMeters:
2001 return 0.001;
2002 case VolumeCubicFeet:
2003 return 0.035314662;
2004 case VolumeCubicYards:
2005 return 0.001307951;
2006 case VolumeBarrel:
2007 return 0.006289811;
2009 case VolumeLiters:
2010 return 1.0;
2011 case VolumeGallonUS:
2012 return 0.264172037;
2013 case VolumeCubicInch:
2014 return 61.023758990;
2016 return 1000;
2017 case VolumeCubicDegrees:
2018 return 0.001 / DEG2_TO_M3; // basically meaningless!
2019 case VolumeUnknownUnit:
2020 return 1.0;
2021 }
2022 break;
2023 }
2024 case VolumeGallonUS:
2025 {
2026 switch ( toUnit )
2027 {
2028 case VolumeCubicMeters:
2029 return 0.003785412;
2030 case VolumeCubicFeet:
2031 return 0.133680547;
2032 case VolumeCubicYards:
2033 return 0.004951132;
2034 case VolumeBarrel:
2035 return 0.023809524;
2037 case VolumeLiters:
2038 return 3.785412000;
2039 case VolumeGallonUS:
2040 return 1.0;
2041 case VolumeCubicInch:
2042 return 231.000069567;
2044 return 3785.412;
2045 case VolumeCubicDegrees:
2046 return 0.003785412 / DEG2_TO_M3; // basically meaningless!
2047 case VolumeUnknownUnit:
2048 return 1.0;
2049 }
2050 break;
2051 }
2052 case VolumeCubicInch:
2053 {
2054 switch ( toUnit )
2055 {
2056 case VolumeCubicMeters:
2057 return 0.000016387;
2058 case VolumeCubicFeet:
2059 return 0.000578703;
2060 case VolumeCubicYards:
2061 return 0.000021433;
2062 case VolumeBarrel:
2063 return 0.000103072;
2065 case VolumeLiters:
2066 return 0.016387060;
2067 case VolumeGallonUS:
2068 return 0.004329003;
2069 case VolumeCubicInch:
2070 return 1.0;
2072 return 16.387060000;
2073 case VolumeCubicDegrees:
2074 return 0.000016387 / DEG2_TO_M3; // basically meaningless!
2075 case VolumeUnknownUnit:
2076 return 1.0;
2077 }
2078 break;
2079 }
2081 {
2082 switch ( toUnit )
2083 {
2084 case VolumeCubicMeters:
2085 return 0.000001;
2086 case VolumeCubicFeet:
2087 return 0.000035315;
2088 case VolumeCubicYards:
2089 return 0.000001308;
2090 case VolumeBarrel:
2091 return 0.000006290;
2093 case VolumeLiters:
2094 return 0.001;
2095 case VolumeGallonUS:
2096 return 0.000264172 ;
2097 case VolumeCubicInch:
2098 return 0.061023759;
2100 return 1.0;
2101 case VolumeCubicDegrees:
2102 return 0.000001 / DEG2_TO_M3; // basically meaningless!
2103 case VolumeUnknownUnit:
2104 return 1.0;
2105 }
2106 break;
2107 }
2108 case VolumeCubicDegrees:
2109 if ( toUnit == VolumeUnknownUnit || toUnit == VolumeCubicDegrees )
2110 return 1.0;
2111 else
2113
2114 case VolumeUnknownUnit:
2115 {
2116 return 1.0;
2117 }
2118 }
2119 return 1.0;
2120}
2121
2123{
2124 switch ( distanceUnit )
2125 {
2126 case DistanceMeters:
2127 return VolumeCubicMeters;
2128
2129 case DistanceKilometers:
2130 return VolumeCubicMeters;
2131
2133 return VolumeCubicCentimeter;
2134
2136 return VolumeCubicCentimeter;
2137
2138 case DistanceFeet:
2139 return VolumeCubicFeet;
2140
2141 case DistanceYards:
2142 return VolumeCubicYards;
2143
2144 case DistanceMiles:
2145 return VolumeCubicFeet;
2146
2147 case DistanceDegrees:
2148 return VolumeCubicDegrees;
2149
2151 return VolumeUnknownUnit;
2152
2154 return VolumeCubicFeet;
2155 }
2156
2157 return VolumeUnknownUnit;
2158}
2159
2161{
2162 switch ( volumeUnit )
2163 {
2164 case VolumeCubicMeters:
2165 return DistanceMeters;
2166 case VolumeCubicFeet:
2167 return DistanceFeet;
2168 case VolumeCubicYards:
2169 return DistanceYards;
2170 case VolumeBarrel:
2171 return DistanceFeet;
2173 return DistanceCentimeters;
2174 case VolumeLiters:
2175 return DistanceMeters;
2176 case VolumeGallonUS:
2177 return DistanceFeet;
2178 case VolumeCubicInch:
2179 return DistanceFeet;
2181 return DistanceCentimeters;
2182 case VolumeCubicDegrees:
2183 return DistanceDegrees;
2184 case VolumeUnknownUnit:
2185 return DistanceUnknownUnit;
2186 }
2187 return DistanceUnknownUnit;
2188}
2189
2191{
2192 switch ( unit )
2193 {
2194 case VolumeCubicMeters:
2195 case VolumeCubicFeet:
2196 case VolumeCubicYards:
2197 case VolumeBarrel:
2199 case VolumeLiters:
2200 case VolumeGallonUS:
2201 case VolumeCubicInch:
2203 return Standard;
2204 case VolumeCubicDegrees:
2205 return Geographic;
2206 case VolumeUnknownUnit:
2207 return UnknownType;
2208 }
2209 return UnknownType;
2210}
2211
2213{
2214 switch ( unit )
2215 {
2216 case VolumeCubicMeters:
2217 return QStringLiteral( "m3" );
2218 case VolumeCubicFeet:
2219 return QStringLiteral( "ft3" );
2220 case VolumeCubicYards:
2221 return QStringLiteral( "yd3" );
2222 case VolumeBarrel:
2223 return QStringLiteral( "bbl" );
2225 return QStringLiteral( "dm3" );
2226 case VolumeLiters:
2227 return QStringLiteral( "l" );
2228 case VolumeGallonUS:
2229 return QStringLiteral( "gal" );
2230 case VolumeCubicInch:
2231 return QStringLiteral( "in3" );
2233 return QStringLiteral( "cm3" );
2234 case VolumeCubicDegrees:
2235 return QStringLiteral( "deg3" );
2236 case VolumeUnknownUnit:
2237 return QStringLiteral( "<unknown>" );
2238 }
2239 return QString();
2240}
2241
2243{
2244 switch ( unit )
2245 {
2246 case AngleDegrees:
2247 return QStringLiteral( "degrees" );
2248 case AngleRadians:
2249 return QStringLiteral( "radians" );
2250 case AngleGon:
2251 return QStringLiteral( "gon" );
2252 case AngleMinutesOfArc:
2253 return QStringLiteral( "moa" );
2254 case AngleSecondsOfArc:
2255 return QStringLiteral( "soa" );
2256 case AngleTurn:
2257 return QStringLiteral( "tr" );
2259 return QStringLiteral( "milliradians" );
2260 case AngleMilNATO:
2261 return QStringLiteral( "mil" );
2262 case AngleUnknownUnit:
2263 return QStringLiteral( "<unknown>" );
2264 }
2265 return QString();
2266}
2267
2269{
2270 const QString normalized = string.trimmed().toLower();
2271
2272 if ( ok )
2273 *ok = true;
2274
2275 if ( normalized == encodeUnit( AngleDegrees ) )
2276 return AngleDegrees;
2277 if ( normalized == encodeUnit( AngleRadians ) )
2278 return AngleRadians;
2279 if ( normalized == encodeUnit( AngleGon ) )
2280 return AngleGon;
2281 if ( normalized == encodeUnit( AngleMinutesOfArc ) )
2282 return AngleMinutesOfArc;
2283 if ( normalized == encodeUnit( AngleSecondsOfArc ) )
2284 return AngleSecondsOfArc;
2285 if ( normalized == encodeUnit( AngleTurn ) )
2286 return AngleTurn;
2287 if ( normalized == encodeUnit( AngleMilliradiansSI ) )
2288 return AngleMilliradiansSI;
2289 if ( normalized == encodeUnit( AngleMilNATO ) )
2290 return AngleMilNATO;
2291 if ( normalized == encodeUnit( AngleUnknownUnit ) )
2292 return AngleUnknownUnit;
2293 if ( ok )
2294 *ok = false;
2295
2296 return AngleUnknownUnit;
2297}
2298
2300{
2301 switch ( unit )
2302 {
2303 case AngleDegrees:
2304 return QObject::tr( "degrees", "angle" );
2305 case AngleRadians:
2306 return QObject::tr( "radians", "angle" );
2307 case AngleGon:
2308 return QObject::tr( "gon", "angle" );
2309 case AngleMinutesOfArc:
2310 return QObject::tr( "minutes of arc", "angle" );
2311 case AngleSecondsOfArc:
2312 return QObject::tr( "seconds of arc", "angle" );
2313 case AngleTurn:
2314 return QObject::tr( "turns", "angle" );
2316 return QObject::tr( "milliradians", "angle" );
2317 case AngleMilNATO:
2318 return QObject::tr( "mil", "angle" );
2319 case AngleUnknownUnit:
2320 return QObject::tr( "<unknown>", "angle" );
2321 }
2322 return QString();
2323}
2324
2326{
2327 // Calculate the conversion factor between the specified units
2328 switch ( fromUnit )
2329 {
2330 case AngleDegrees:
2331 {
2332 switch ( toUnit )
2333 {
2334 case AngleDegrees:
2335 return 1.0;
2336 case AngleRadians:
2337 return M_PI / 180.0;
2338 case AngleGon:
2339 return 400.0 / 360.0;
2340 case AngleMinutesOfArc:
2341 return 60;
2342 case AngleSecondsOfArc:
2343 return 3600;
2344 case AngleTurn:
2345 return 1.0 / 360.0;
2347 return M_PI / 180.0 * 1000;
2348 case AngleMilNATO:
2349 return 3200.0 / 180;
2350 case AngleUnknownUnit:
2351 break;
2352 }
2353 break;
2354 }
2355 case AngleRadians:
2356 {
2357 switch ( toUnit )
2358 {
2359 case AngleDegrees:
2360 return 180.0 / M_PI;
2361 case AngleRadians:
2362 return 1.0;
2363 case AngleGon:
2364 return 200.0 / M_PI;
2365 case AngleMinutesOfArc:
2366 return 60 * 180.0 / M_PI;
2367 case AngleSecondsOfArc:
2368 return 3600 * 180.0 / M_PI;
2369 case AngleTurn:
2370 return 0.5 / M_PI;
2372 return 1000;
2373 case AngleMilNATO:
2374 return 3200.0 / M_PI;
2375 case AngleUnknownUnit:
2376 break;
2377 }
2378 break;
2379 }
2380 case AngleGon:
2381 {
2382 switch ( toUnit )
2383 {
2384 case AngleDegrees:
2385 return 360.0 / 400.0;
2386 case AngleRadians:
2387 return M_PI / 200.0;
2388 case AngleGon:
2389 return 1.0;
2390 case AngleMinutesOfArc:
2391 return 60 * 360.0 / 400.0;
2392 case AngleSecondsOfArc:
2393 return 3600 * 360.0 / 400.0;
2394 case AngleTurn:
2395 return 1.0 / 400.0;
2397 return M_PI / 200.0 * 1000;
2398 case AngleMilNATO:
2399 return 3200.0 / 200.0;
2400 case AngleUnknownUnit:
2401 break;
2402 }
2403 break;
2404 }
2405 case AngleMinutesOfArc:
2406 {
2407 switch ( toUnit )
2408 {
2409 case AngleDegrees:
2410 return 1 / 60.0;
2411 case AngleRadians:
2412 return M_PI / 180.0 / 60.0;
2413 case AngleGon:
2414 return 400.0 / 360.0 / 60.0;
2415 case AngleMinutesOfArc:
2416 return 1.0;
2417 case AngleSecondsOfArc:
2418 return 60.0;
2419 case AngleTurn:
2420 return 1.0 / 360.0 / 60.0;
2422 return M_PI / 180.0 / 60.0 * 1000;
2423 case AngleMilNATO:
2424 return 3200.0 / 180.0 / 60.0;
2425 case AngleUnknownUnit:
2426 break;
2427 }
2428 break;
2429 }
2430 case AngleSecondsOfArc:
2431 {
2432 switch ( toUnit )
2433 {
2434 case AngleDegrees:
2435 return 1 / 3600.0;
2436 case AngleRadians:
2437 return M_PI / 180.0 / 3600.0;
2438 case AngleGon:
2439 return 400.0 / 360.0 / 3600.0;
2440 case AngleMinutesOfArc:
2441 return 1.0 / 60.0;
2442 case AngleSecondsOfArc:
2443 return 1.0;
2444 case AngleTurn:
2445 return 1.0 / 360.0 / 3600.0;
2447 return M_PI / 180.0 / 3600.0 * 1000;
2448 case AngleMilNATO:
2449 return 3200.0 / 180.0 / 3600.0;
2450 case AngleUnknownUnit:
2451 break;
2452 }
2453 break;
2454 }
2455 case AngleTurn:
2456 {
2457 switch ( toUnit )
2458 {
2459 case AngleDegrees:
2460 return 360.0;
2461 case AngleRadians:
2462 return 2 * M_PI;
2463 case AngleGon:
2464 return 400.0;
2465 case AngleMinutesOfArc:
2466 return 360.0 * 60.0;
2467 case AngleSecondsOfArc:
2468 return 360.0 * 3600.0;
2469 case AngleTurn:
2470 return 1.0;
2472 return 2 * M_PI * 1000;
2473 case AngleMilNATO:
2474 return 2 * 3200;
2475 case AngleUnknownUnit:
2476 break;
2477 }
2478 break;
2479 }
2481 {
2482 switch ( toUnit )
2483 {
2484 case AngleDegrees:
2485 return 180.0 / M_PI / 1000;
2486 case AngleRadians:
2487 return 0.001;
2488 case AngleGon:
2489 return 200.0 / M_PI / 1000;
2490 case AngleMinutesOfArc:
2491 return 180.0 * 60.0 / M_PI / 1000;
2492 case AngleSecondsOfArc:
2493 return 180.0 * 3600.0 / M_PI / 1000;
2494 case AngleTurn:
2495 return M_PI / 2 / 1000;
2497 return 1.0;
2498 case AngleMilNATO:
2499 return 3200.0 / 1000.0 / M_PI;
2500 case AngleUnknownUnit:
2501 break;
2502 }
2503 break;
2504 }
2505
2506 case AngleMilNATO:
2507 {
2508 switch ( toUnit )
2509 {
2510 case AngleDegrees:
2511 return 180.0 / 3200;
2512 case AngleRadians:
2513 return M_PI / 3200;
2514 case AngleGon:
2515 return 200.0 / 3200;
2516 case AngleMinutesOfArc:
2517 return 60 * 180.0 / 3200;
2518 case AngleSecondsOfArc:
2519 return 3600.0 * 180 / 3200;
2520 case AngleTurn:
2521 return 1.0 / ( 2 * 32000 );
2523 return 1000.0 * M_PI / 3200.0;
2524 case AngleMilNATO:
2525 return 1.0;
2526 case AngleUnknownUnit:
2527 break;
2528 }
2529 break;
2530 }
2531
2532 case AngleUnknownUnit:
2533 break;
2534 }
2535 return 1.0;
2536}
2537
2538QString QgsUnitTypes::formatAngle( double angle, int decimals, QgsUnitTypes::AngleUnit unit )
2539{
2540 QString unitLabel;
2541 int decimalPlaces = 2;
2542
2543 switch ( unit )
2544 {
2545 case AngleDegrees:
2546 unitLabel = QObject::tr( "°", "angle" );
2547 decimalPlaces = 0;
2548 break;
2549 case AngleRadians:
2550 unitLabel = QObject::tr( " rad", "angle" );
2551 decimalPlaces = 2;
2552 break;
2553 case AngleGon:
2554 unitLabel = QObject::tr( " gon", "angle" );
2555 decimalPlaces = 0;
2556 break;
2557 case AngleMinutesOfArc:
2558 unitLabel = QObject::tr( "′", "angle minutes" );
2559 decimalPlaces = 0;
2560 break;
2561 case AngleSecondsOfArc:
2562 unitLabel = QObject::tr( "″", "angle seconds" );
2563 decimalPlaces = 0;
2564 break;
2565 case AngleTurn:
2566 unitLabel = QObject::tr( " tr", "angle turn" );
2567 decimalPlaces = 3;
2568 break;
2570 unitLabel = QObject::tr( " millirad", "angular mil SI" );
2571 decimalPlaces = 0;
2572 break;
2573 case AngleMilNATO:
2574 unitLabel = QObject::tr( " mil", "angular mil NATO" );
2575 decimalPlaces = 0;
2576 break;
2577 case AngleUnknownUnit:
2578 break;
2579 }
2580
2581 if ( decimals >= 0 )
2582 decimalPlaces = decimals;
2583
2584 return QStringLiteral( "%L1%2" ).arg( angle, 0, 'f', decimalPlaces ).arg( unitLabel );
2585}
2586
2587QgsUnitTypes::DistanceValue QgsUnitTypes::scaledDistance( double distance, QgsUnitTypes::DistanceUnit unit, int decimals, bool keepBaseUnit )
2588{
2589 DistanceValue result;
2590
2591 switch ( unit )
2592 {
2593 case DistanceMeters:
2594 if ( keepBaseUnit )
2595 {
2596 result.value = qgsRound( distance, decimals );
2598 }
2599 else if ( std::fabs( distance ) > 1000.0 )
2600 {
2601 result.value = qgsRound( distance / 1000, decimals );
2603 }
2604 else if ( std::fabs( distance ) < 0.01 )
2605 {
2606 result.value = qgsRound( distance * 1000, decimals );
2608 }
2609 else if ( std::fabs( distance ) < 0.1 )
2610 {
2611
2612 result.value = qgsRound( distance * 100, decimals );
2614 }
2615 else
2616 {
2617 result.value = qgsRound( distance, decimals );
2619 }
2620 break;
2621
2622 case DistanceKilometers:
2623 if ( keepBaseUnit || std::fabs( distance ) >= 1.0 )
2624 {
2625 result.value = qgsRound( distance, decimals );
2627 }
2628 else
2629 {
2630 result.value = qgsRound( distance * 1000, decimals );
2632 }
2633 break;
2634
2635 case DistanceFeet:
2636 if ( std::fabs( distance ) <= 5280.0 || keepBaseUnit )
2637 {
2638 result.value = qgsRound( distance, decimals );
2640 }
2641 else
2642 {
2643 result.value = qgsRound( distance / 5280.0, decimals );
2645 }
2646 break;
2647
2648 case DistanceYards:
2649 if ( std::fabs( distance ) <= 1760.0 || keepBaseUnit )
2650 {
2651 result.value = qgsRound( distance, decimals );
2653 }
2654 else
2655 {
2656 result.value = qgsRound( distance / 1760.0, decimals );
2658 }
2659 break;
2660
2661 case DistanceMiles:
2662 if ( std::fabs( distance ) >= 1.0 || keepBaseUnit )
2663 {
2664 result.value = qgsRound( distance, decimals );
2666 }
2667 else
2668 {
2669 result.value = qgsRound( distance * 5280.0, decimals );
2671 }
2672 break;
2673
2675 result.value = qgsRound( distance, decimals );
2677 break;
2678
2679 case DistanceDegrees:
2680 result.value = qgsRound( distance, decimals );
2682 break;
2683
2685 result.value = qgsRound( distance, decimals );
2687 break;
2688
2689 default:
2690 result.value = qgsRound( distance, decimals );
2691 result.unit = unit;
2692 break;
2693 }
2694
2695 return result;
2696}
2697
2698QgsUnitTypes::AreaValue QgsUnitTypes::scaledArea( double area, QgsUnitTypes::AreaUnit unit, int decimals, bool keepBaseUnit )
2699{
2700 AreaValue result;
2701 result.value = -1.0;
2702 result.unit = AreaUnknownUnit;
2703
2704 // If we are not forced to keep the base units, switch to meter calculation
2705 if ( unit == AreaSquareMillimeters )
2706 {
2707 if ( keepBaseUnit )
2708 {
2709 result.value = qgsRound( area, decimals );
2711 }
2712 else
2713 {
2714 area /= 1000000.0;
2716 }
2717 }
2718 else if ( unit == AreaSquareCentimeters )
2719 {
2720 if ( keepBaseUnit )
2721 {
2722 result.value = qgsRound( area, decimals );
2724 }
2725 else
2726 {
2727 area /= 10000.0;
2729 }
2730 }
2731
2732 switch ( unit )
2733 {
2735 // handled in the if above
2736 break;
2738 // handled in the if above
2739 break;
2740 case AreaSquareMeters:
2741 {
2742 if ( keepBaseUnit )
2743 {
2744 result.value = qgsRound( area, decimals );
2746 }
2748 {
2751 }
2753 {
2756 }
2757 else
2758 {
2759 result.value = qgsRound( area, decimals );
2761 }
2762 break;
2763 }
2764
2766 {
2767 result.value = qgsRound( area, decimals );
2769 break;
2770 }
2771
2772 case AreaSquareFeet:
2773 {
2774 if ( keepBaseUnit )
2775 {
2776 result.value = qgsRound( area, decimals );
2778 }
2780 {
2783 }
2784 else
2785 {
2786 result.value = qgsRound( area, decimals );
2788 }
2789 break;
2790 }
2791
2792 case AreaSquareYards:
2793 {
2794 if ( keepBaseUnit )
2795 {
2796 result.value = qgsRound( area, decimals );
2798 }
2800 {
2803 }
2804 else
2805 {
2806 result.value = qgsRound( area, decimals );
2808 }
2809 break;
2810 }
2811
2812 case AreaSquareMiles:
2813 {
2814 result.value = qgsRound( area, decimals );
2816 break;
2817 }
2818
2819 case AreaHectares:
2820 {
2821 if ( keepBaseUnit )
2822 {
2823 result.value = qgsRound( area, decimals );
2825 }
2827 {
2830 }
2831 else
2832 {
2833 result.value = qgsRound( area, decimals );
2835 }
2836 break;
2837 }
2838
2839 case AreaAcres:
2840 {
2841 if ( keepBaseUnit )
2842 {
2843 result.value = qgsRound( area, decimals );
2845 }
2847 {
2850 }
2851 else
2852 {
2853 result.value = qgsRound( area, decimals );
2855 }
2856 break;
2857 }
2858
2860 {
2861 result.value = qgsRound( area, decimals );
2863 break;
2864 }
2865
2866 case AreaSquareDegrees:
2867 {
2868 result.value = qgsRound( area, decimals );
2870 break;
2871 }
2872
2873 case AreaUnknownUnit:
2874 {
2875 result.value = qgsRound( area, decimals );
2877 break;
2878 }
2879 }
2880 return result;
2881}
2882
2883
2884QString QgsUnitTypes::formatDistance( double distance, int decimals, QgsUnitTypes::DistanceUnit unit, bool keepBaseUnit )
2885{
2886 const DistanceValue dist = scaledDistance( distance, unit, decimals, keepBaseUnit );
2887
2888 QString unitText;
2889
2890 if ( dist.unit != DistanceUnknownUnit )
2891 unitText = QChar( ' ' ) + QgsUnitTypes::toAbbreviatedString( dist.unit );
2892
2893 if ( qgsDoubleNear( dist.value, 0 ) )
2894 {
2895 unitText = QChar( ' ' ) + QgsUnitTypes::toAbbreviatedString( unit );
2896 return QStringLiteral( "%L1%2" ).arg( distance, 0, 'e', decimals ).arg( unitText );
2897 }
2898 else
2899 {
2900 return QStringLiteral( "%L1%2" ).arg( dist.value, 0, 'f', decimals ).arg( unitText );
2901 }
2902}
2903
2904QString QgsUnitTypes::formatArea( double area, int decimals, QgsUnitTypes::AreaUnit unit, bool keepBaseUnit )
2905{
2906 const AreaValue areaValue = scaledArea( area, unit, decimals, keepBaseUnit );
2907
2908 QString unitText;
2909
2910 if ( areaValue.unit != AreaUnknownUnit )
2911 unitText = QChar( ' ' ) + QgsUnitTypes::toAbbreviatedString( areaValue.unit );
2912
2913 if ( qgsDoubleNear( areaValue.value, 0 ) )
2914 {
2915 unitText = QChar( ' ' ) + QgsUnitTypes::toAbbreviatedString( unit );
2916 return QStringLiteral( "%L1%2" ).arg( area, 0, 'e', decimals ).arg( unitText );
2917 }
2918 else
2919 {
2920 return QStringLiteral( "%L1%2" ).arg( areaValue.value, 0, 'f', decimals ).arg( unitText );
2921 }
2922}
2923
2925{
2926 switch ( unit )
2927 {
2928 case RenderMillimeters:
2929 return QStringLiteral( "MM" );
2931 return QStringLiteral( "RenderMetersInMapUnits" );
2932 case RenderMapUnits:
2933 return QStringLiteral( "MapUnit" );
2934 case RenderPixels:
2935 return QStringLiteral( "Pixel" );
2936 case RenderPercentage:
2937 return QStringLiteral( "Percentage" );
2938 case RenderPoints:
2939 return QStringLiteral( "Point" );
2940 case RenderInches:
2941 return QStringLiteral( "Inch" );
2942 case RenderUnknownUnit:
2943 return QString();
2944 }
2945 return QString();
2946}
2947
2949{
2950 const QString normalized = string.trimmed().toLower();
2951
2952 if ( ok )
2953 *ok = true;
2954
2955 if ( normalized == encodeUnit( RenderMillimeters ).toLower() )
2956 return RenderMillimeters;
2957 if ( normalized == encodeUnit( RenderMetersInMapUnits ).toLower() )
2959 if ( normalized == QLatin1String( "meters" ) )
2961 if ( normalized == encodeUnit( RenderMapUnits ).toLower() )
2962 return RenderMapUnits;
2963 if ( normalized == QLatin1String( "mapunits" ) )
2964 return RenderMapUnits;
2965 if ( normalized == encodeUnit( RenderPixels ).toLower() )
2966 return RenderPixels;
2967 if ( normalized == encodeUnit( RenderPercentage ).toLower() )
2968 return RenderPercentage;
2969 if ( normalized == QLatin1String( "percent" ) )
2970 return RenderPercentage;
2971 if ( normalized == encodeUnit( RenderPoints ).toLower() )
2972 return RenderPoints;
2973 if ( normalized == QLatin1String( "points" ) )
2974 return RenderPoints;
2975 if ( normalized == encodeUnit( RenderInches ).toLower() )
2976 return RenderInches;
2977
2978 if ( ok )
2979 *ok = false;
2980
2981 // millimeters are default
2982 return RenderMillimeters;
2983}
2984
2986{
2987 switch ( unit )
2988 {
2989 case RenderMillimeters:
2990 return QObject::tr( "millimeters", "render" );
2991
2993 return QObject::tr( "meters at scale", "render" );
2994
2995 case RenderMapUnits:
2996 return QObject::tr( "map units", "render" );
2997
2998 case RenderPixels:
2999 return QObject::tr( "pixels", "render" );
3000
3001 case RenderPercentage:
3002 return QObject::tr( "percent", "render" );
3003
3004 case RenderPoints:
3005 return QObject::tr( "points", "render" );
3006
3007 case RenderInches:
3008 return QObject::tr( "inches", "render" );
3009
3010 case RenderUnknownUnit:
3011 return QObject::tr( "<unknown>", "render" );
3012
3013 }
3014 return QString();
3015}
3016
3017
3018
3020{
3021 switch ( unit )
3022 {
3023 case LayoutCentimeters:
3024 return QStringLiteral( "cm" );
3025 case LayoutMeters:
3026 return QStringLiteral( "m" );
3027 case LayoutInches:
3028 return QStringLiteral( "in" );
3029 case LayoutFeet:
3030 return QStringLiteral( "ft" );
3031 case LayoutPoints:
3032 return QStringLiteral( "pt" );
3033 case LayoutPicas:
3034 return QStringLiteral( "pi" );
3035 case LayoutPixels:
3036 return QStringLiteral( "px" );
3037 case LayoutMillimeters:
3038 return QStringLiteral( "mm" );
3039 }
3040 return QString();
3041}
3042
3044{
3045 const QString normalized = string.trimmed().toLower();
3046
3047 if ( ok )
3048 *ok = true;
3049
3050 if ( normalized == encodeUnit( LayoutMillimeters ).toLower() )
3051 return LayoutMillimeters;
3052 if ( normalized == encodeUnit( LayoutCentimeters ).toLower() )
3053 return LayoutCentimeters;
3054 if ( normalized == encodeUnit( LayoutMeters ).toLower() )
3055 return LayoutMeters;
3056 if ( normalized == encodeUnit( LayoutInches ).toLower() )
3057 return LayoutInches;
3058 if ( normalized == encodeUnit( LayoutFeet ).toLower() )
3059 return LayoutFeet;
3060 if ( normalized == encodeUnit( LayoutPoints ).toLower() )
3061 return LayoutPoints;
3062 if ( normalized == encodeUnit( LayoutPicas ).toLower() )
3063 return LayoutPicas;
3064 if ( normalized == encodeUnit( LayoutPixels ).toLower() )
3065 return LayoutPixels;
3066
3067 if ( ok )
3068 *ok = false;
3069
3070 // millimeters are default
3071 return LayoutMillimeters;
3072}
3073
3075{
3076 switch ( units )
3077 {
3078 case LayoutPixels:
3079 return LayoutScreenUnits;
3080 case LayoutMillimeters:
3081 case LayoutCentimeters:
3082 case LayoutMeters:
3083 case LayoutInches:
3084 case LayoutFeet:
3085 case LayoutPoints:
3086 case LayoutPicas:
3087 return LayoutPaperUnits;
3088 }
3089
3090 // avoid warnings
3091 return LayoutPaperUnits;
3092}
3093
3095{
3096 switch ( unit )
3097 {
3098 case LayoutPixels:
3099 return QObject::tr( "px" );
3100 case LayoutMillimeters:
3101 return QObject::tr( "mm" );
3102 case LayoutCentimeters:
3103 return QObject::tr( "cm" );
3104 case LayoutMeters:
3105 return QObject::tr( "m" );
3106 case LayoutInches:
3107 return QObject::tr( "in", "unit inch" );
3108 case LayoutFeet:
3109 return QObject::tr( "ft" );
3110 case LayoutPoints:
3111 return QObject::tr( "pt" );
3112 case LayoutPicas:
3113 return QObject::tr( "pica" );
3114 }
3115 return QString(); // no warnings
3116}
3117
3119{
3120 switch ( unit )
3121 {
3122 case LayoutPixels:
3123 return QObject::tr( "pixels" );
3124 case LayoutMillimeters:
3125 return QObject::tr( "millimeters" );
3126 case LayoutCentimeters:
3127 return QObject::tr( "centimeters" );
3128 case LayoutMeters:
3129 return QObject::tr( "meters" );
3130 case LayoutInches:
3131 return QObject::tr( "inches" );
3132 case LayoutFeet:
3133 return QObject::tr( "feet" );
3134 case LayoutPoints:
3135 return QObject::tr( "points" );
3136 case LayoutPicas:
3137 return QObject::tr( "picas" );
3138 }
3139 return QString(); // no warnings
3140}
static Q_INVOKABLE QgsUnitTypes::VolumeUnit decodeVolumeUnit(const QString &string, bool *ok=nullptr)
Decodes a volume unit from a string.
DistanceUnit
Units of distance.
Definition: qgsunittypes.h:68
@ DistanceMeters
Meters.
Definition: qgsunittypes.h:69
@ DistanceDegrees
Degrees, for planar geographic CRS distance measurements.
Definition: qgsunittypes.h:75
@ DistanceKilometers
Kilometers.
Definition: qgsunittypes.h:70
@ DistanceMiles
Terrestrial miles.
Definition: qgsunittypes.h:74
@ DistanceUnknownUnit
Unknown distance unit.
Definition: qgsunittypes.h:78
@ DistanceMillimeters
Millimeters.
Definition: qgsunittypes.h:77
@ DistanceYards
Imperial yards.
Definition: qgsunittypes.h:73
@ DistanceFeet
Imperial feet.
Definition: qgsunittypes.h:71
@ DistanceNauticalMiles
Nautical miles.
Definition: qgsunittypes.h:72
@ DistanceCentimeters
Centimeters.
Definition: qgsunittypes.h:76
LayoutUnit
Layout measurement units.
Definition: qgsunittypes.h:182
@ LayoutInches
Inches.
Definition: qgsunittypes.h:186
@ LayoutMillimeters
Millimeters.
Definition: qgsunittypes.h:183
@ LayoutFeet
Feet.
Definition: qgsunittypes.h:187
@ LayoutCentimeters
Centimeters.
Definition: qgsunittypes.h:184
@ LayoutPixels
Pixels.
Definition: qgsunittypes.h:190
@ LayoutPicas
Typographic picas.
Definition: qgsunittypes.h:189
@ LayoutPoints
Typographic points.
Definition: qgsunittypes.h:188
@ LayoutMeters
Meters.
Definition: qgsunittypes.h:185
static Q_INVOKABLE QgsUnitTypes::TemporalUnit stringToTemporalUnit(const QString &string, bool *ok=nullptr)
Converts a translated string to a temporal unit.
AngleUnit
Units of angles.
Definition: qgsunittypes.h:132
@ AngleGon
Gon/gradian.
Definition: qgsunittypes.h:135
@ AngleRadians
Square kilometers.
Definition: qgsunittypes.h:134
@ AngleDegrees
Degrees.
Definition: qgsunittypes.h:133
@ AngleMilNATO
Angular mil (NATO definition, 6400 mil = 2PI radians)
Definition: qgsunittypes.h:140
@ AngleMilliradiansSI
Angular milliradians (SI definition, 1/1000 of radian)
Definition: qgsunittypes.h:139
@ AngleTurn
Turn/revolutions.
Definition: qgsunittypes.h:138
@ AngleUnknownUnit
Unknown angle unit.
Definition: qgsunittypes.h:141
@ AngleMinutesOfArc
Minutes of arc.
Definition: qgsunittypes.h:136
@ AngleSecondsOfArc
Seconds of arc.
Definition: qgsunittypes.h:137
static Q_INVOKABLE QString encodeUnit(QgsUnitTypes::DistanceUnit unit)
Encodes a distance unit to a string.
static Q_INVOKABLE QgsUnitTypes::AreaUnit distanceToAreaUnit(QgsUnitTypes::DistanceUnit distanceUnit)
Converts a distance unit to its corresponding area unit, e.g., meters to square meters.
static Q_INVOKABLE QgsUnitTypes::VolumeUnit stringToVolumeUnit(const QString &string, bool *ok=nullptr)
Converts a translated string to a volume unit.
static Q_INVOKABLE QgsUnitTypes::AngleUnit decodeAngleUnit(const QString &string, bool *ok=nullptr)
Decodes an angular unit from a string.
VolumeUnit
Units of volume.
Definition: qgsunittypes.h:115
@ VolumeBarrel
Barrels.
Definition: qgsunittypes.h:119
@ VolumeCubicYards
Cubic yards.
Definition: qgsunittypes.h:118
@ VolumeCubicMeters
Cubic meters.
Definition: qgsunittypes.h:116
@ VolumeCubicDecimeter
Cubic decimeters.
Definition: qgsunittypes.h:120
@ VolumeCubicCentimeter
Cubic Centimeters.
Definition: qgsunittypes.h:124
@ VolumeCubicDegrees
Cubic degrees, for planar geographic CRS volume measurements.
Definition: qgsunittypes.h:125
@ VolumeCubicFeet
Cubic feet.
Definition: qgsunittypes.h:117
@ VolumeLiters
Litres.
Definition: qgsunittypes.h:121
@ VolumeCubicInch
Cubic inches.
Definition: qgsunittypes.h:123
@ VolumeUnknownUnit
Unknown volume unit.
Definition: qgsunittypes.h:126
@ VolumeGallonUS
US Gallons.
Definition: qgsunittypes.h:122
static Q_INVOKABLE QgsUnitTypes::DistanceUnit decodeDistanceUnit(const QString &string, bool *ok=nullptr)
Decodes a distance unit from a string.
static Q_INVOKABLE QString toString(QgsUnitTypes::DistanceUnit unit)
Returns a translated string representing a distance unit.
static Q_INVOKABLE QgsUnitTypes::DistanceUnit areaToDistanceUnit(QgsUnitTypes::AreaUnit areaUnit)
Converts an area unit to its corresponding distance unit, e.g., square meters to meters.
static Q_INVOKABLE QgsUnitTypes::DistanceUnit stringToDistanceUnit(const QString &string, bool *ok=nullptr)
Converts a translated string to a distance unit.
static Q_INVOKABLE double fromUnitToUnitFactor(QgsUnitTypes::DistanceUnit fromUnit, QgsUnitTypes::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
static Q_INVOKABLE QgsUnitTypes::AreaUnit stringToAreaUnit(const QString &string, bool *ok=nullptr)
Converts a translated string to an areal unit.
static Q_INVOKABLE QgsUnitTypes::DistanceUnit volumeToDistanceUnit(QgsUnitTypes::VolumeUnit volumeUnit)
Converts a volume unit to its corresponding distance unit, e.g., cubic meters to meters.
static Q_INVOKABLE QString toAbbreviatedString(QgsUnitTypes::DistanceUnit unit)
Returns a translated abbreviation representing a distance unit.
static Q_INVOKABLE QgsUnitTypes::DistanceUnitType unitType(QgsUnitTypes::DistanceUnit unit)
Returns the type for a distance unit.
static Q_INVOKABLE QgsUnitTypes::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
static Q_INVOKABLE QgsUnitTypes::AreaValue scaledArea(double area, QgsUnitTypes::AreaUnit unit, int decimals, bool keepBaseUnit=false)
Will convert an area with a given unit to an area value which is nice to display.
static Q_INVOKABLE QString formatArea(double area, int decimals, QgsUnitTypes::AreaUnit unit, bool keepBaseUnit=false)
Returns an area formatted as a friendly string.
static Q_INVOKABLE QgsUnitTypes::LayoutUnit decodeLayoutUnit(const QString &string, bool *ok=nullptr)
Decodes a layout unit from a string.
static Q_INVOKABLE QgsUnitTypes::AreaUnit decodeAreaUnit(const QString &string, bool *ok=nullptr)
Decodes an areal unit from a string.
DistanceUnitType
Types of distance units.
Definition: qgsunittypes.h:86
@ Geographic
Unit is a geographic (e.g., degree based) unit.
Definition: qgsunittypes.h:88
@ Standard
Unit is a standard measurement unit.
Definition: qgsunittypes.h:87
@ UnknownType
Unknown unit type.
Definition: qgsunittypes.h:89
UnitType
Unit types.
Definition: qgsunittypes.h:58
@ TypeDistance
Distance unit.
Definition: qgsunittypes.h:59
@ TypeTemporal
Temporal unit.
Definition: qgsunittypes.h:63
@ TypeArea
Area unit.
Definition: qgsunittypes.h:60
@ TypeVolume
Volume unit.
Definition: qgsunittypes.h:61
@ TypeUnknown
Unknown unit type.
Definition: qgsunittypes.h:62
static Q_INVOKABLE QgsUnitTypes::DistanceValue scaledDistance(double distance, QgsUnitTypes::DistanceUnit unit, int decimals, bool keepBaseUnit=false)
Will convert a distance with a given unit to a distance value which is nice to display.
static Q_INVOKABLE QgsUnitTypes::VolumeUnit distanceToVolumeUnit(QgsUnitTypes::DistanceUnit distanceUnit)
Converts a distance unit to its corresponding volume unit, e.g., meters to cubic meters.
AreaUnit
Units of area.
Definition: qgsunittypes.h:94
@ AreaSquareNauticalMiles
Square nautical miles.
Definition: qgsunittypes.h:102
@ AreaSquareYards
Square yards.
Definition: qgsunittypes.h:98
@ AreaSquareFeet
Square feet.
Definition: qgsunittypes.h:97
@ AreaHectares
Hectares.
Definition: qgsunittypes.h:100
@ AreaUnknownUnit
Unknown areal unit.
Definition: qgsunittypes.h:106
@ AreaSquareMeters
Square meters.
Definition: qgsunittypes.h:95
@ AreaSquareMiles
Square miles.
Definition: qgsunittypes.h:99
@ AreaSquareCentimeters
Square centimeters.
Definition: qgsunittypes.h:104
@ AreaSquareKilometers
Square kilometers.
Definition: qgsunittypes.h:96
@ AreaSquareDegrees
Square degrees, for planar geographic CRS area measurements.
Definition: qgsunittypes.h:103
@ AreaAcres
Acres.
Definition: qgsunittypes.h:101
@ AreaSquareMillimeters
Square millimeters.
Definition: qgsunittypes.h:105
TemporalUnit
Temporal units.
Definition: qgsunittypes.h:150
@ TemporalMonths
Months.
Definition: qgsunittypes.h:157
@ TemporalUnknownUnit
Unknown time unit.
Definition: qgsunittypes.h:162
@ TemporalWeeks
Weeks.
Definition: qgsunittypes.h:156
@ TemporalMilliseconds
Milliseconds.
Definition: qgsunittypes.h:151
@ TemporalIrregularStep
Special "irregular step" time unit, used for temporal data which uses irregular, non-real-world unit ...
Definition: qgsunittypes.h:161
@ TemporalDays
Days.
Definition: qgsunittypes.h:155
@ TemporalDecades
Decades.
Definition: qgsunittypes.h:159
@ TemporalCenturies
Centuries.
Definition: qgsunittypes.h:160
@ TemporalSeconds
Seconds.
Definition: qgsunittypes.h:152
@ TemporalMinutes
Minutes.
Definition: qgsunittypes.h:153
@ TemporalYears
Years.
Definition: qgsunittypes.h:158
@ TemporalHours
Hours.
Definition: qgsunittypes.h:154
static Q_INVOKABLE QgsUnitTypes::TemporalUnit decodeTemporalUnit(const QString &string, bool *ok=nullptr)
Decodes a temporal unit from a string.
static Q_INVOKABLE QString formatDistance(double distance, int decimals, QgsUnitTypes::DistanceUnit unit, bool keepBaseUnit=false)
Returns an distance formatted as a friendly string.
static Q_INVOKABLE QgsUnitTypes::UnitType decodeUnitType(const QString &string, bool *ok=nullptr)
Decodes a unit type from a string.
static Q_INVOKABLE QString encodeUnitType(QgsUnitTypes::UnitType type)
Encodes a unit type to a string.
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168
@ RenderUnknownUnit
Mixed or unknown units.
Definition: qgsunittypes.h:175
@ RenderMetersInMapUnits
Meters value as Map units.
Definition: qgsunittypes.h:176
@ RenderPercentage
Percentage of another measurement (e.g., canvas size, feature size)
Definition: qgsunittypes.h:172
@ RenderPoints
Points (e.g., for font sizes)
Definition: qgsunittypes.h:173
@ RenderPixels
Pixels.
Definition: qgsunittypes.h:171
@ RenderInches
Inches.
Definition: qgsunittypes.h:174
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
@ RenderMapUnits
Map units.
Definition: qgsunittypes.h:170
static Q_INVOKABLE QString formatAngle(double angle, int decimals, QgsUnitTypes::AngleUnit unit)
Returns an angle formatted as a friendly string.
LayoutUnitType
Types of layout units.
Definition: qgsunittypes.h:196
@ LayoutScreenUnits
Unit is a screen based measurement unit.
Definition: qgsunittypes.h:198
@ LayoutPaperUnits
Unit is a paper based measurement unit.
Definition: qgsunittypes.h:197
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Definition: MathUtils.cpp:786
double qgsRound(double number, int places)
Returns a double number, rounded (as close as possible) to the specified number of places.
Definition: qgis.h:2969
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:2915
#define DEGREE_TO_METER
#define MILLIMETERS_TO_METER
#define KM2_TO_M2
#define CENTIMETERS_TO_METER
#define DEG2_TO_M3
#define MI2_TO_M2
#define AC_TO_FT2
#define NMILE_TO_METER
#define KILOMETERS_TO_METER
#define YARDS_TO_FEET
#define FEET_TO_METER
#define YD2_TO_M2
#define NM2_TO_M2
#define MM2_TO_M2
#define DEG2_TO_M2
#define CM2_TO_M2
#define FT2_TO_M2
#define MILES_TO_METER
#define YARDS_TO_METER
#define HA_TO_M2
A combination of area value and unit.
Definition: qgsunittypes.h:226
double value
The value part of the distance.
Definition: qgsunittypes.h:231
QgsUnitTypes::AreaUnit unit
The value part of the distance.
Definition: qgsunittypes.h:236
A combination of distance value and unit.
Definition: qgsunittypes.h:207
QgsUnitTypes::DistanceUnit unit
The value part of the distance.
Definition: qgsunittypes.h:217
double value
The value part of the distance.
Definition: qgsunittypes.h:212