QGIS API Documentation  2.18.21-Las Palmas (9fba24a)
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 <QCoreApplication>
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 
26 QgsUnitTypes::DistanceUnitType QgsUnitTypes::unitType( QGis::UnitType unit )
27 {
28  switch ( unit )
29  {
30  case QGis::Meters:
31  case QGis::Feet:
32  case QGis::NauticalMiles:
33  case QGis::Yards:
34  case QGis::Miles:
35  case QGis::Kilometers:
36  return Standard;
37 
38  case QGis::Degrees:
39  return Geographic;
40 
41  case QGis::UnknownUnit:
42  return UnknownType;
43  }
44  return UnknownType;
45 }
46 
47 QgsUnitTypes::DistanceUnitType QgsUnitTypes::unitType( QgsUnitTypes::AreaUnit unit )
48 {
49  switch ( unit )
50  {
51  case SquareMeters:
52  case SquareKilometers:
53  case SquareFeet:
54  case SquareYards:
55  case SquareMiles:
56  case Hectares:
57  case Acres:
58  case SquareNauticalMiles:
59  return Standard;
60 
61  case SquareDegrees:
62  return Geographic;
63 
64  case UnknownAreaUnit:
65  return UnknownType;
66  }
67 
68  return UnknownType;
69 }
70 
71 QString QgsUnitTypes::encodeUnit( QGis::UnitType unit )
72 {
73  switch ( unit )
74  {
75  case QGis::Meters:
76  return "meters";
77 
78  case QGis::Kilometers:
79  return "km";
80 
81  case QGis::Feet:
82  return "feet";
83 
84  case QGis::Yards:
85  return "yd";
86 
87  case QGis::Miles:
88  return "mi";
89 
90  case QGis::Degrees:
91  return "degrees";
92 
93  case QGis::UnknownUnit:
94  return "<unknown>";
95 
96  case QGis::NauticalMiles:
97  return "nautical miles";
98  }
99  return QString();
100 }
101 
102 /***************************************************************************
103  * This class is considered CRITICAL and any change MUST be accompanied with
104  * full unit tests in test_qgsunittypes.py.
105  * See details in QEP #17
106  ****************************************************************************/
107 
108 QGis::UnitType QgsUnitTypes::decodeDistanceUnit( const QString& string, bool* ok )
109 {
110  QString normalized = string.trimmed().toLower();
111 
112  if ( ok )
113  *ok = true;
114 
115  if ( normalized == encodeUnit( QGis::Meters ) )
116  return QGis::Meters;
117  if ( normalized == encodeUnit( QGis::Feet ) )
118  return QGis::Feet;
119  if ( normalized == encodeUnit( QGis::Degrees ) )
120  return QGis::Degrees;
121  if ( normalized == encodeUnit( QGis::NauticalMiles ) )
122  return QGis::NauticalMiles;
123  if ( normalized == encodeUnit( QGis::Kilometers ) )
124  return QGis::Kilometers;
125  if ( normalized == encodeUnit( QGis::Yards ) )
126  return QGis::Yards;
127  if ( normalized == encodeUnit( QGis::Miles ) )
128  return QGis::Miles;
129  if ( normalized == encodeUnit( QGis::UnknownUnit ) )
130  return QGis::UnknownUnit;
131 
132  if ( ok )
133  *ok = false;
134 
135  return QGis::UnknownUnit;
136 }
137 
138 QString QgsUnitTypes::toString( QGis::UnitType unit )
139 {
140  switch ( unit )
141  {
142  case QGis::Meters:
143  return QCoreApplication::translate( "QGis::UnitType", "meters" );
144 
145  case QGis::Kilometers:
146  return QCoreApplication::translate( "QGis::UnitType", "kilometers" );
147 
148  case QGis::Feet:
149  return QCoreApplication::translate( "QGis::UnitType", "feet" );
150 
151  case QGis::Yards:
152  return QCoreApplication::translate( "QGis::UnitType", "yards" );
153 
154  case QGis::Miles:
155  return QCoreApplication::translate( "QGis::UnitType", "miles" );
156 
157  case QGis::Degrees:
158  return QCoreApplication::translate( "QGis::UnitType", "degrees" );
159 
160  case QGis::UnknownUnit:
161  return QCoreApplication::translate( "QGis::UnitType", "<unknown>" );
162 
163  case QGis::NauticalMiles:
164  return QCoreApplication::translate( "QGis::UnitType", "nautical miles" );
165  }
166  return QString();
167 }
168 
169 /***************************************************************************
170  * This class is considered CRITICAL and any change MUST be accompanied with
171  * full unit tests in test_qgsunittypes.py.
172  * See details in QEP #17
173  ****************************************************************************/
174 
175 QGis::UnitType QgsUnitTypes::stringToDistanceUnit( const QString& string, bool* ok )
176 {
177  QString normalized = string.trimmed().toLower();
178 
179  if ( ok )
180  *ok = true;
181 
182  if ( normalized == toString( QGis::Meters ) )
183  return QGis::Meters;
184  if ( normalized == toString( QGis::Kilometers ) )
185  return QGis::Kilometers;
186  if ( normalized == toString( QGis::Feet ) )
187  return QGis::Feet;
188  if ( normalized == toString( QGis::Yards ) )
189  return QGis::Yards;
190  if ( normalized == toString( QGis::Miles ) )
191  return QGis::Miles;
192  if ( normalized == toString( QGis::Degrees ) )
193  return QGis::Degrees;
194  if ( normalized == toString( QGis::NauticalMiles ) )
195  return QGis::NauticalMiles;
196  if ( normalized == toString( QGis::UnknownUnit ) )
197  return QGis::UnknownUnit;
198 
199  if ( ok )
200  *ok = false;
201 
202  return QGis::UnknownUnit;
203 }
204 
205 /***************************************************************************
206  * This class is considered CRITICAL and any change MUST be accompanied with
207  * full unit tests in test_qgsunittypes.py.
208  * See details in QEP #17
209  ****************************************************************************/
210 
211 double QgsUnitTypes::fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit )
212 {
213 #define DEGREE_TO_METER 111319.49079327358
214 #define FEET_TO_METER 0.3048
215 #define NMILE_TO_METER 1852.0
216 #define KILOMETERS_TO_METER 1000.0
217 #define YARDS_TO_METER 0.9144
218 #define YARDS_TO_FEET 3.0
219 #define MILES_TO_METER 1609.344
220  // Unify degree units
221  // remove for QGIS 3.0, as extra degree types will be removed
222  if ( fromUnit == QGis::DecimalDegrees || fromUnit == QGis::DegreesMinutesSeconds || fromUnit == QGis::DegreesDecimalMinutes )
223  fromUnit = QGis::Degrees;
224  if ( toUnit == QGis::DecimalDegrees || toUnit == QGis::DegreesMinutesSeconds || toUnit == QGis::DegreesDecimalMinutes )
225  toUnit = QGis::Degrees;
226 
227  // Calculate the conversion factor between the specified units
228  switch ( fromUnit )
229  {
230  case QGis::Meters:
231  {
232  switch ( toUnit )
233  {
234  case QGis::Meters:
235  return 1.0;
236  case QGis::Kilometers:
237  return 1.0 / KILOMETERS_TO_METER;
238  case QGis::Feet:
239  return 1.0 / FEET_TO_METER;
240  case QGis::Yards:
241  return 1.0 / YARDS_TO_METER;
242  case QGis::Miles:
243  return 1.0 / MILES_TO_METER;
244  case QGis::Degrees:
245  return 1.0 / DEGREE_TO_METER;
246  case QGis::NauticalMiles:
247  return 1.0 / NMILE_TO_METER;
248  case QGis::UnknownUnit:
249  break;
250  }
251 
252  break;
253  }
254  case QGis::Kilometers:
255  {
256  switch ( toUnit )
257  {
258  case QGis::Meters:
259  return KILOMETERS_TO_METER;
260  case QGis::Kilometers:
261  return 1.0;
262  case QGis::Feet:
263  return KILOMETERS_TO_METER / FEET_TO_METER;
264  case QGis::Yards:
265  return KILOMETERS_TO_METER / YARDS_TO_METER;
266  case QGis::Miles:
267  return KILOMETERS_TO_METER / MILES_TO_METER;
268  case QGis::Degrees:
269  return KILOMETERS_TO_METER / DEGREE_TO_METER;
270  case QGis::NauticalMiles:
271  return KILOMETERS_TO_METER / NMILE_TO_METER;
272  case QGis::UnknownUnit:
273  break;
274  }
275 
276  break;
277  }
278  case QGis::Feet:
279  {
280  switch ( toUnit )
281  {
282  case QGis::Meters:
283  return FEET_TO_METER;
284  case QGis::Kilometers:
285  return FEET_TO_METER / KILOMETERS_TO_METER;
286  case QGis::Feet:
287  return 1.0;
288  case QGis::Yards:
289  return 1.0 / YARDS_TO_FEET;
290  case QGis::Miles:
291  return FEET_TO_METER / MILES_TO_METER;
292  case QGis::Degrees:
293  return FEET_TO_METER / DEGREE_TO_METER;
294  case QGis::NauticalMiles:
295  return FEET_TO_METER / NMILE_TO_METER;
296  case QGis::UnknownUnit:
297  break;
298  }
299 
300  break;
301  }
302  case QGis::Yards:
303  {
304  switch ( toUnit )
305  {
306  case QGis::Meters:
307  return YARDS_TO_METER;
308  case QGis::Kilometers:
309  return YARDS_TO_METER / KILOMETERS_TO_METER;
310  case QGis::Feet:
311  return YARDS_TO_FEET;
312  case QGis::Yards:
313  return 1.0;
314  case QGis::Miles:
315  return YARDS_TO_METER / MILES_TO_METER;
316  case QGis::Degrees:
317  return YARDS_TO_METER / DEGREE_TO_METER;
318  case QGis::NauticalMiles:
319  return YARDS_TO_METER / NMILE_TO_METER;
320  case QGis::UnknownUnit:
321  break;
322  }
323 
324  break;
325  }
326  case QGis::Miles:
327  {
328  switch ( toUnit )
329  {
330  case QGis::Meters:
331  return MILES_TO_METER;
332  case QGis::Kilometers:
333  return MILES_TO_METER / KILOMETERS_TO_METER;
334  case QGis::Feet:
335  return MILES_TO_METER / FEET_TO_METER;
336  case QGis::Yards:
337  return MILES_TO_METER / YARDS_TO_METER;
338  case QGis::Miles:
339  return 1.0;
340  case QGis::Degrees:
341  return MILES_TO_METER / DEGREE_TO_METER;
342  case QGis::NauticalMiles:
343  return MILES_TO_METER / NMILE_TO_METER;
344  case QGis::UnknownUnit:
345  break;
346  }
347 
348  break;
349  }
350  case QGis::Degrees:
351  {
352  switch ( toUnit )
353  {
354  case QGis::Meters:
355  return DEGREE_TO_METER;
356  case QGis::Kilometers:
357  return DEGREE_TO_METER / KILOMETERS_TO_METER;
358  case QGis::Feet:
359  return DEGREE_TO_METER / FEET_TO_METER;
360  case QGis::Yards:
361  return DEGREE_TO_METER / YARDS_TO_METER;
362  case QGis::Miles:
363  return DEGREE_TO_METER / MILES_TO_METER;
364  case QGis::Degrees:
365  return 1.0;
366  case QGis::NauticalMiles:
367  return DEGREE_TO_METER / NMILE_TO_METER;
368  case QGis::UnknownUnit:
369  break;
370  }
371 
372  break;
373  }
374  case QGis::NauticalMiles:
375  {
376  switch ( toUnit )
377  {
378  case QGis::Meters:
379  return NMILE_TO_METER;
380  case QGis::Kilometers:
381  return NMILE_TO_METER / KILOMETERS_TO_METER;
382  case QGis::Feet:
383  return NMILE_TO_METER / FEET_TO_METER;
384  case QGis::Yards:
385  return NMILE_TO_METER / YARDS_TO_METER;
386  case QGis::Miles:
387  return NMILE_TO_METER / MILES_TO_METER;
388  case QGis::Degrees:
389  return NMILE_TO_METER / DEGREE_TO_METER;
390  case QGis::NauticalMiles:
391  return 1.0;
392  case QGis::UnknownUnit:
393  break;
394  }
395 
396  break;
397  }
398  case QGis::UnknownUnit:
399  break;
400  }
401  return 1.0;
402 }
403 
404 QString QgsUnitTypes::encodeUnit( QgsUnitTypes::AreaUnit unit )
405 {
406  switch ( unit )
407  {
408  case SquareMeters:
409  return "m2";
410  case SquareKilometers:
411  return "km2";
412  case SquareFeet:
413  return "ft2";
414  case SquareYards:
415  return "y2";
416  case SquareMiles:
417  return "mi2";
418  case Hectares:
419  return "ha";
420  case Acres:
421  return "ac";
422  case SquareNauticalMiles:
423  return "nm2";
424  case SquareDegrees:
425  return "deg2";
426  case UnknownAreaUnit:
427  return "<unknown>";
428  }
429  return QString();
430 }
431 
432 QgsUnitTypes::AreaUnit QgsUnitTypes::decodeAreaUnit( const QString& string, bool* ok )
433 {
434  QString normalized = string.trimmed().toLower();
435 
436  if ( ok )
437  *ok = true;
438 
439  if ( normalized == encodeUnit( SquareMeters ) )
440  return SquareMeters;
441  if ( normalized == encodeUnit( SquareKilometers ) )
442  return SquareKilometers;
443  if ( normalized == encodeUnit( SquareFeet ) )
444  return SquareFeet;
445  if ( normalized == encodeUnit( SquareYards ) )
446  return SquareYards;
447  if ( normalized == encodeUnit( SquareMiles ) )
448  return SquareMiles;
449  if ( normalized == encodeUnit( Hectares ) )
450  return Hectares;
451  if ( normalized == encodeUnit( Acres ) )
452  return Acres;
453  if ( normalized == encodeUnit( SquareNauticalMiles ) )
454  return SquareNauticalMiles;
455  if ( normalized == encodeUnit( SquareDegrees ) )
456  return SquareDegrees;
457  if ( normalized == encodeUnit( UnknownAreaUnit ) )
458  return UnknownAreaUnit;
459 
460  if ( ok )
461  *ok = false;
462 
463  return UnknownAreaUnit;
464 }
465 
466 QString QgsUnitTypes::toString( QgsUnitTypes::AreaUnit unit )
467 {
468  switch ( unit )
469  {
470  case SquareMeters:
471  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "square meters" );
472  case SquareKilometers:
473  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "square kilometers" );
474  case SquareFeet:
475  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "square feet" );
476  case SquareYards:
477  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "square yards" );
478  case SquareMiles:
479  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "square miles" );
480  case Hectares:
481  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "hectares" );
482  case Acres:
483  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "acres" );
484  case SquareNauticalMiles:
485  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "square nautical miles" );
486  case SquareDegrees:
487  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "square degrees" );
488  case UnknownAreaUnit:
489  return QCoreApplication::translate( "QgsUnitTypes::AreaUnit", "<unknown>" );
490  }
491  return QString();
492 }
493 
494 QgsUnitTypes::AreaUnit QgsUnitTypes::stringToAreaUnit( const QString& string, bool* ok )
495 {
496  QString normalized = string.trimmed().toLower();
497 
498  if ( ok )
499  *ok = true;
500 
501  if ( normalized == toString( SquareMeters ) )
502  return SquareMeters;
503  if ( normalized == toString( SquareKilometers ) )
504  return SquareKilometers;
505  if ( normalized == toString( SquareFeet ) )
506  return SquareFeet;
507  if ( normalized == toString( SquareYards ) )
508  return SquareYards;
509  if ( normalized == toString( SquareMiles ) )
510  return SquareMiles;
511  if ( normalized == toString( Hectares ) )
512  return Hectares;
513  if ( normalized == toString( Acres ) )
514  return Acres;
515  if ( normalized == toString( SquareNauticalMiles ) )
516  return SquareNauticalMiles;
517  if ( normalized == toString( SquareDegrees ) )
518  return SquareDegrees;
519  if ( normalized == toString( UnknownAreaUnit ) )
520  return UnknownAreaUnit;
521  if ( ok )
522  *ok = false;
523 
524  return UnknownAreaUnit;
525 }
526 
527 double QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::AreaUnit fromUnit, QgsUnitTypes::AreaUnit toUnit )
528 {
529 #define KM2_TO_M2 1000000.0
530 #define FT2_TO_M2 0.09290304
531 #define YD2_TO_M2 0.83612736
532 #define MI2_TO_M2 2589988.110336
533 #define HA_TO_M2 10000.0
534 #define AC_TO_FT2 43560.0
535 #define DEG2_TO_M2 12392029030.5
536 #define NM2_TO_M2 3429904.0
537 
538  // Calculate the conversion factor between the specified units
539  switch ( fromUnit )
540  {
541  case SquareMeters:
542  {
543  switch ( toUnit )
544  {
545  case SquareMeters:
546  return 1.0;
547  case SquareKilometers:
548  return 1.0 / KM2_TO_M2;
549  case SquareFeet:
550  return 1.0 / FT2_TO_M2;
551  case SquareYards:
552  return 1.0 / YD2_TO_M2;
553  case SquareMiles:
554  return 1.0 / MI2_TO_M2;
555  case Hectares:
556  return 1.0 / HA_TO_M2;
557  case Acres:
558  return 1.0 / AC_TO_FT2 / FT2_TO_M2;
559  case SquareNauticalMiles:
560  return 1.0 / NM2_TO_M2;
561  case SquareDegrees:
562  return 1.0 / DEG2_TO_M2;
563  case UnknownAreaUnit:
564  break;
565  }
566 
567  break;
568  }
569  case SquareKilometers:
570  {
571  switch ( toUnit )
572  {
573  case SquareMeters:
574  return KM2_TO_M2;
575  case SquareKilometers:
576  return 1.0;
577  case SquareFeet:
578  return KM2_TO_M2 / FT2_TO_M2 ;
579  case SquareYards:
580  return KM2_TO_M2 / YD2_TO_M2;
581  case SquareMiles:
582  return KM2_TO_M2 / MI2_TO_M2;
583  case Hectares:
584  return KM2_TO_M2 / HA_TO_M2;
585  case Acres:
586  return KM2_TO_M2 / AC_TO_FT2 / FT2_TO_M2;
587  case SquareNauticalMiles:
588  return KM2_TO_M2 / NM2_TO_M2;
589  case SquareDegrees:
590  return KM2_TO_M2 / DEG2_TO_M2;
591  case UnknownAreaUnit:
592  break;
593  }
594 
595  break;
596  }
597  case SquareFeet:
598  {
599  switch ( toUnit )
600  {
601  case SquareMeters:
602  return FT2_TO_M2;
603  case SquareKilometers:
604  return FT2_TO_M2 / KM2_TO_M2;
605  case SquareFeet:
606  return 1.0;
607  case SquareYards:
608  return FT2_TO_M2 / YD2_TO_M2;
609  case SquareMiles:
610  return FT2_TO_M2 / MI2_TO_M2;
611  case Hectares:
612  return FT2_TO_M2 / HA_TO_M2;
613  case Acres:
614  return 1.0 / AC_TO_FT2;
615  case SquareNauticalMiles:
616  return FT2_TO_M2 / NM2_TO_M2;
617  case SquareDegrees:
618  return FT2_TO_M2 / DEG2_TO_M2;
619  case UnknownAreaUnit:
620  break;
621  }
622 
623  break;
624  }
625 
626  case SquareYards:
627  {
628  switch ( toUnit )
629  {
630  case SquareMeters:
631  return YD2_TO_M2;
632  case SquareKilometers:
633  return YD2_TO_M2 / KM2_TO_M2;
634  case SquareFeet:
635  return YD2_TO_M2 / FT2_TO_M2;
636  case SquareYards:
637  return 1.0;
638  case SquareMiles:
639  return YD2_TO_M2 / MI2_TO_M2;
640  case Hectares:
641  return YD2_TO_M2 / HA_TO_M2;
642  case Acres:
643  return YD2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
644  case SquareNauticalMiles:
645  return YD2_TO_M2 / NM2_TO_M2;
646  case SquareDegrees:
647  return YD2_TO_M2 / DEG2_TO_M2;
648  case UnknownAreaUnit:
649  break;
650  }
651  break;
652  }
653 
654  case SquareMiles:
655  {
656  switch ( toUnit )
657  {
658  case SquareMeters:
659  return MI2_TO_M2;
660  case SquareKilometers:
661  return MI2_TO_M2 / KM2_TO_M2;
662  case SquareFeet:
663  return MI2_TO_M2 / FT2_TO_M2;
664  case SquareYards:
665  return MI2_TO_M2 / YD2_TO_M2;
666  case SquareMiles:
667  return 1.0;
668  case Hectares:
669  return MI2_TO_M2 / HA_TO_M2;
670  case Acres:
671  return MI2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
672  case SquareNauticalMiles:
673  return MI2_TO_M2 / NM2_TO_M2;
674  case SquareDegrees:
675  return MI2_TO_M2 / DEG2_TO_M2;
676  case UnknownAreaUnit:
677  break;
678  }
679 
680  break;
681  }
682 
683  case Hectares:
684  {
685  switch ( toUnit )
686  {
687  case SquareMeters:
688  return HA_TO_M2;
689  case SquareKilometers:
690  return HA_TO_M2 / KM2_TO_M2;
691  case SquareFeet:
692  return HA_TO_M2 / FT2_TO_M2;
693  case SquareYards:
694  return HA_TO_M2 / YD2_TO_M2;
695  case SquareMiles:
696  return HA_TO_M2 / MI2_TO_M2;
697  case Hectares:
698  return 1.0;
699  case Acres:
700  return HA_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
701  case SquareNauticalMiles:
702  return HA_TO_M2 / NM2_TO_M2;
703  case SquareDegrees:
704  return HA_TO_M2 / DEG2_TO_M2;
705  case UnknownAreaUnit:
706  break;
707  }
708 
709  break;
710  }
711 
712  case Acres:
713  {
714  switch ( toUnit )
715  {
716  case SquareMeters:
717  return AC_TO_FT2 * FT2_TO_M2;
718  case SquareKilometers:
719  return AC_TO_FT2 * FT2_TO_M2 / KM2_TO_M2;
720  case SquareFeet:
721  return AC_TO_FT2;
722  case SquareYards:
723  return AC_TO_FT2 * FT2_TO_M2 / YD2_TO_M2;
724  case SquareMiles:
725  return AC_TO_FT2 * FT2_TO_M2 / MI2_TO_M2;
726  case Hectares:
727  return AC_TO_FT2 * FT2_TO_M2 / HA_TO_M2;
728  case Acres:
729  return 1.0;
730  case SquareNauticalMiles:
731  return AC_TO_FT2 * FT2_TO_M2 / NM2_TO_M2;
732  case SquareDegrees:
733  return AC_TO_FT2 * FT2_TO_M2 / DEG2_TO_M2;
734  case UnknownAreaUnit:
735  break;
736  }
737 
738  break;
739  }
740 
741  case SquareNauticalMiles:
742  {
743  switch ( toUnit )
744  {
745  case SquareMeters:
746  return NM2_TO_M2;
747  case SquareKilometers:
748  return NM2_TO_M2 / KM2_TO_M2;
749  case SquareFeet:
750  return NM2_TO_M2 / FT2_TO_M2;
751  case SquareYards:
752  return NM2_TO_M2 / YD2_TO_M2;
753  case SquareMiles:
754  return NM2_TO_M2 / MI2_TO_M2;
755  case Hectares:
756  return NM2_TO_M2 / HA_TO_M2;
757  case Acres:
758  return NM2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
759  case SquareNauticalMiles:
760  return 1.0;
761  case SquareDegrees:
762  return NM2_TO_M2 / DEG2_TO_M2;
763  case UnknownAreaUnit:
764  break;
765  }
766 
767  break;
768  }
769 
770  case SquareDegrees:
771  {
772  switch ( toUnit )
773  {
774  case SquareMeters:
775  return DEG2_TO_M2;
776  case SquareKilometers:
777  return DEG2_TO_M2 / KM2_TO_M2;
778  case SquareFeet:
779  return DEG2_TO_M2 / FT2_TO_M2;
780  case SquareYards:
781  return DEG2_TO_M2 / YD2_TO_M2;
782  case SquareMiles:
783  return DEG2_TO_M2 / MI2_TO_M2;
784  case Hectares:
785  return DEG2_TO_M2 / HA_TO_M2;
786  case Acres:
787  return DEG2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
788  case SquareNauticalMiles:
789  return DEG2_TO_M2 / NM2_TO_M2;
790  case SquareDegrees:
791  return 1.0;
792  case UnknownAreaUnit:
793  break;
794  }
795 
796  break;
797  }
798 
799  case UnknownAreaUnit:
800  break;
801  }
802  return 1.0;
803 }
804 
805 QgsUnitTypes::AreaUnit QgsUnitTypes::distanceToAreaUnit( QGis::UnitType distanceUnit )
806 {
807  switch ( distanceUnit )
808  {
809  case QGis::Meters:
810  return SquareMeters;
811 
812  case QGis::Kilometers:
813  return SquareKilometers;
814 
815  case QGis::Feet:
816  return SquareFeet;
817 
818  case QGis::Yards:
819  return SquareYards;
820 
821  case QGis::Miles:
822  return SquareMiles;
823 
824  case QGis::Degrees:
825  return SquareDegrees;
826 
827  case QGis::UnknownUnit:
828  return UnknownAreaUnit;
829 
830  case QGis::NauticalMiles:
831  return SquareNauticalMiles;
832  }
833 
834  return UnknownAreaUnit;
835 }
836 
837 QString QgsUnitTypes::encodeUnit( QgsUnitTypes::AngleUnit unit )
838 {
839  switch ( unit )
840  {
841  case AngleDegrees:
842  return "degrees";
843  case Radians:
844  return "radians";
845  case Gon:
846  return "gon";
847  case MinutesOfArc:
848  return "moa";
849  case SecondsOfArc:
850  return "soa";
851  case Turn:
852  return "tr";
853  case UnknownAngleUnit:
854  return "<unknown>";
855  }
856  return QString();
857 }
858 
859 QgsUnitTypes::AngleUnit QgsUnitTypes::decodeAngleUnit( const QString& string, bool* ok )
860 {
861  QString normalized = string.trimmed().toLower();
862 
863  if ( ok )
864  *ok = true;
865 
866  if ( normalized == encodeUnit( AngleDegrees ) )
867  return AngleDegrees;
868  if ( normalized == encodeUnit( Radians ) )
869  return Radians;
870  if ( normalized == encodeUnit( Gon ) )
871  return Gon;
872  if ( normalized == encodeUnit( MinutesOfArc ) )
873  return MinutesOfArc;
874  if ( normalized == encodeUnit( SecondsOfArc ) )
875  return SecondsOfArc;
876  if ( normalized == encodeUnit( Turn ) )
877  return Turn;
878  if ( normalized == encodeUnit( UnknownAngleUnit ) )
879  return UnknownAngleUnit;
880  if ( ok )
881  *ok = false;
882 
883  return UnknownAngleUnit;
884 }
885 
886 QString QgsUnitTypes::toString( QgsUnitTypes::AngleUnit unit )
887 {
888  switch ( unit )
889  {
890  case AngleDegrees:
891  return QCoreApplication::translate( "QgsUnitTypes::AngleUnit", "degrees" );
892  case Radians:
893  return QCoreApplication::translate( "QgsUnitTypes::AngleUnit", "radians" );
894  case Gon:
895  return QCoreApplication::translate( "QgsUnitTypes::AngleUnit", "gon" );
896  case MinutesOfArc:
897  return QCoreApplication::translate( "QgsUnitTypes::AngleUnit", "minutes of arc" );
898  case SecondsOfArc:
899  return QCoreApplication::translate( "QgsUnitTypes::AngleUnit", "seconds of arc" );
900  case Turn:
901  return QCoreApplication::translate( "QgsUnitTypes::AngleUnit", "turns" );
902  case UnknownAngleUnit:
903  return QCoreApplication::translate( "QgsUnitTypes::AngleUnit", "<unknown>" );
904  }
905  return QString();
906 }
907 
908 double QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::AngleUnit fromUnit, QgsUnitTypes::AngleUnit toUnit )
909 {
910  // Calculate the conversion factor between the specified units
911  switch ( fromUnit )
912  {
913  case AngleDegrees:
914  {
915  switch ( toUnit )
916  {
917  case AngleDegrees:
918  return 1.0;
919  case Radians:
920  return M_PI / 180.0;
921  case Gon:
922  return 400.0 / 360.0;
923  case MinutesOfArc:
924  return 60;
925  case SecondsOfArc:
926  return 3600;
927  case Turn:
928  return 1.0 / 360.0;
929  case UnknownAngleUnit:
930  break;
931  }
932  break;
933  }
934  case Radians:
935  {
936  switch ( toUnit )
937  {
938  case AngleDegrees:
939  return 180.0 / M_PI;
940  case Radians:
941  return 1.0;
942  case Gon:
943  return 200.0 / M_PI;
944  case MinutesOfArc:
945  return 60 * 180.0 / M_PI;
946  case SecondsOfArc:
947  return 3600 * 180.0 / M_PI;
948  case Turn:
949  return 0.5 / M_PI;
950  case UnknownAngleUnit:
951  break;
952  }
953  break;
954  }
955  case Gon:
956  {
957  switch ( toUnit )
958  {
959  case AngleDegrees:
960  return 360.0 / 400.0;
961  case Radians:
962  return M_PI / 200.0;
963  case Gon:
964  return 1.0;
965  case MinutesOfArc:
966  return 60 * 360.0 / 400.0;
967  case SecondsOfArc:
968  return 3600 * 360.0 / 400.0;
969  case Turn:
970  return 1.0 / 400.0;
971  case UnknownAngleUnit:
972  break;
973  }
974  break;
975  }
976  case MinutesOfArc:
977  {
978  switch ( toUnit )
979  {
980  case AngleDegrees:
981  return 1 / 60.0;
982  case Radians:
983  return M_PI / 180.0 / 60.0;
984  case Gon:
985  return 400.0 / 360.0 / 60.0;
986  case MinutesOfArc:
987  return 1.0;
988  case SecondsOfArc:
989  return 60.0;
990  case Turn:
991  return 1.0 / 360.0 / 60.0;
992  case UnknownAngleUnit:
993  break;
994  }
995  break;
996  }
997  case SecondsOfArc:
998  {
999  switch ( toUnit )
1000  {
1001  case AngleDegrees:
1002  return 1 / 3600.0;
1003  case Radians:
1004  return M_PI / 180.0 / 3600.0;
1005  case Gon:
1006  return 400.0 / 360.0 / 3600.0;
1007  case MinutesOfArc:
1008  return 1.0 / 60.0;
1009  case SecondsOfArc:
1010  return 1.0;
1011  case Turn:
1012  return 1.0 / 360.0 / 3600.0;
1013  case UnknownAngleUnit:
1014  break;
1015  }
1016  break;
1017  }
1018  case Turn:
1019  {
1020  switch ( toUnit )
1021  {
1022  case AngleDegrees:
1023  return 360.0;
1024  case Radians:
1025  return 2 * M_PI;
1026  case Gon:
1027  return 400.0;
1028  case MinutesOfArc:
1029  return 360.0 * 60.0;
1030  case SecondsOfArc:
1031  return 360.0 * 3600.0;
1032  case Turn:
1033  return 1.0;
1034  case UnknownAngleUnit:
1035  break;
1036  }
1037  break;
1038  }
1039  case UnknownAngleUnit:
1040  break;
1041  }
1042  return 1.0;
1043 }
1044 
1045 QString QgsUnitTypes::formatAngle( double angle, int decimals, QgsUnitTypes::AngleUnit unit )
1046 {
1047  QString unitLabel;
1048 
1049  switch ( unit )
1050  {
1051  case AngleDegrees:
1052  unitLabel = QObject::trUtf8( "°" );
1053  break;
1054  case Radians:
1055  unitLabel = QObject::trUtf8( " rad" );
1056  break;
1057  case Gon:
1058  unitLabel = QObject::trUtf8( " gon" );
1059  break;
1060  case MinutesOfArc:
1061  unitLabel = QObject::trUtf8( "′" );
1062  break;
1063  case SecondsOfArc:
1064  unitLabel = QObject::trUtf8( "″" );
1065  break;
1066  case Turn:
1067  unitLabel = QObject::trUtf8( " tr" );
1068  break;
1069  case UnknownAngleUnit:
1070  break;
1071  }
1072 
1073  return QString( "%L1%2" ).arg( angle, 0, 'f', decimals ).arg( unitLabel );
1074 }
1075 
1076 // enable for QGIS 3.0
1077 #if 0
1078 
1079 QString QgsUnitTypes::encodeUnit( QgsSymbolV2::OutputUnit unit )
1080 {
1081  switch ( unit )
1082  {
1083  case QgsSymbolV2::MM:
1084  return "MM";
1085  case QgsSymbolV2::MapUnit:
1086  return "MapUnit";
1087  case QgsSymbolV2::Pixel:
1088  return "Pixel";
1089  case QgsSymbolV2::Percentage:
1090  return "Percentage";
1091  default:
1092  return "MM";
1093  }
1094 }
1095 
1096 QgsSymbolV2::OutputUnit QgsUnitTypes::decodeSymbolUnit( const QString& string, bool* ok )
1097 {
1098  QString normalized = string.trimmed().toLower();
1099 
1100  if ( ok )
1101  *ok = true;
1102 
1103  if ( normalized == encodeUnit( QgsSymbolV2::MM ).toLower() )
1104  return QgsSymbolV2::MM;
1105  if ( normalized == encodeUnit( QgsSymbolV2::MapUnit ).toLower() )
1106  return QgsSymbolV2::MapUnit;
1107  if ( normalized == encodeUnit( QgsSymbolV2::Pixel ).toLower() )
1108  return QgsSymbolV2::Pixel;
1109  if ( normalized == encodeUnit( QgsSymbolV2::Percentage ).toLower() )
1110  return QgsSymbolV2::Percentage;
1111 
1112  if ( ok )
1113  *ok = false;
1114 
1115  // millimeters are default
1116  return QgsSymbolV2::MM;
1117 }
1118 
1119 #endif
HA_TO_M2
#define HA_TO_M2
QgsUnitTypes::formatAngle
static QString formatAngle(double angle, int decimals, AngleUnit unit)
Returns an angle formatted as a friendly string.
Definition: qgsunittypes.cpp:1045
DEGREE_TO_METER
#define DEGREE_TO_METER
QgsSymbolV2::OutputUnit
OutputUnit
The unit of the output.
Definition: qgssymbolv2.h:65
QgsUnitTypes::unitType
static DistanceUnitType unitType(QGis::UnitType unit)
Returns the type for a distance unit.
Definition: qgsunittypes.cpp:26
QgsUnitTypes::decodeAreaUnit
static AreaUnit decodeAreaUnit(const QString &string, bool *ok=0)
Decodes an areal unit from a string.
Definition: qgsunittypes.cpp:432
MI2_TO_M2
#define MI2_TO_M2
QgsUnitTypes::decodeDistanceUnit
static QGis::UnitType decodeDistanceUnit(const QString &string, bool *ok=0)
Decodes a distance unit from a string.
Definition: qgsunittypes.cpp:108
QgsSymbolV2::Pixel
The output shall be in pixels.
Definition: qgssymbolv2.h:70
QgsUnitTypes::DistanceUnitType
DistanceUnitType
Types of distance units.
Definition: qgsunittypes.h:41
NMILE_TO_METER
#define NMILE_TO_METER
KM2_TO_M2
#define KM2_TO_M2
QObject::trUtf8
QString trUtf8(const char *sourceText, const char *disambiguation, int n)
KILOMETERS_TO_METER
#define KILOMETERS_TO_METER
FEET_TO_METER
#define FEET_TO_METER
QgsUnitTypes::AngleUnit
AngleUnit
Units of angles.
Definition: qgsunittypes.h:64
AC_TO_FT2
#define AC_TO_FT2
QgsUnitTypes::encodeUnit
static QString encodeUnit(QGis::UnitType unit)
Encodes a distance unit to a string.
Definition: qgsunittypes.cpp:71
QgsUnitTypes::toString
static QString toString(QGis::UnitType unit)
Returns a translated string representing a distance unit.
Definition: qgsunittypes.cpp:138
QgsSymbolV2::MM
The output shall be in millimeters.
Definition: qgssymbolv2.h:67
YARDS_TO_METER
#define YARDS_TO_METER
QgsUnitTypes::stringToDistanceUnit
static QGis::UnitType stringToDistanceUnit(const QString &string, bool *ok=0)
Converts a translated string to a distance unit.
Definition: qgsunittypes.cpp:175
DEG2_TO_M2
#define DEG2_TO_M2
QgsSymbolV2::Percentage
The ouput shall be a percentage of another measurement (eg canvas size, feature size) ...
Definition: qgssymbolv2.h:71
FT2_TO_M2
#define FT2_TO_M2
QString::trimmed
QString trimmed() const
QgsSymbolV2::MapUnit
The output shall be in map unitx.
Definition: qgssymbolv2.h:68
M_PI
#define M_PI
Definition: qgsdistancearea.cpp:42
NM2_TO_M2
#define NM2_TO_M2
QgsUnitTypes::fromUnitToUnitFactor
static double fromUnitToUnitFactor(QGis::UnitType fromUnit, QGis::UnitType toUnit)
Returns the conversion factor between the specified distance units.
Definition: qgsunittypes.cpp:211
MathUtils::angle
double ANALYSIS_EXPORT angle(Point3D *p1, Point3D *p2, Point3D *p3, Point3D *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
QString::toLower
QString toLower() const
QgsUnitTypes::decodeAngleUnit
static AngleUnit decodeAngleUnit(const QString &string, bool *ok=0)
Decodes an angular unit from a string.
Definition: qgsunittypes.cpp:859
QgsUnitTypes::distanceToAreaUnit
static AreaUnit distanceToAreaUnit(QGis::UnitType distanceUnit)
Converts a distance unit to its corresponding area unit, eg meters to square meters.
Definition: qgsunittypes.cpp:805
QCoreApplication::translate
QString translate(const char *context, const char *sourceText, const char *disambiguation, Encoding encoding)
QgsUnitTypes::stringToAreaUnit
static AreaUnit stringToAreaUnit(const QString &string, bool *ok=0)
Converts a translated string to an areal unit.
Definition: qgsunittypes.cpp:494
QGis::UnitType
UnitType
Map units that qgis supports.
Definition: qgis.h:159
MILES_TO_METER
#define MILES_TO_METER
YARDS_TO_FEET
#define YARDS_TO_FEET
QString::arg
QString arg(qlonglong a, int fieldWidth, int base, const QChar &fillChar) const
QgsUnitTypes::AreaUnit
AreaUnit
Units of area.
Definition: qgsunittypes.h:49
YD2_TO_M2
#define YD2_TO_M2
Generated on Sun Jun 24 2018 11:42:48 for QGIS API Documentation by   doxygen 1.8.13