QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
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
26QString QgsUnitTypes::encodeUnitType( Qgis::UnitType type )
27{
28 switch ( type )
29 {
30 case Qgis::UnitType::Distance:
31 return QStringLiteral( "distance" );
32
33 case Qgis::UnitType::Area:
34 return QStringLiteral( "area" );
35
36 case Qgis::UnitType::Volume:
37 return QStringLiteral( "volume" );
38
39 case Qgis::UnitType::Temporal:
40 return QStringLiteral( "temporal" );
41
42 case Qgis::UnitType::Unknown:
43 return QStringLiteral( "<unknown>" );
44
45 }
46 return QString();
47}
48
49Qgis::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( Qgis::UnitType::Distance ) )
57 return Qgis::UnitType::Distance;
58 if ( normalized == encodeUnitType( Qgis::UnitType::Area ) )
59 return Qgis::UnitType::Area;
60 if ( normalized == encodeUnitType( Qgis::UnitType::Volume ) )
61 return Qgis::UnitType::Volume;
62 if ( normalized == encodeUnitType( Qgis::UnitType::Temporal ) )
63 return Qgis::UnitType::Temporal;
64 if ( normalized == encodeUnitType( Qgis::UnitType::Unknown ) )
65 return Qgis::UnitType::Unknown;
66
67 if ( ok )
68 *ok = false;
69
70 return Qgis::UnitType::Unknown;
71}
72
73Qgis::DistanceUnitType QgsUnitTypes::unitType( Qgis::DistanceUnit unit )
74{
75 switch ( unit )
76 {
77 case Qgis::DistanceUnit::Meters:
78 case Qgis::DistanceUnit::Feet:
79 case Qgis::DistanceUnit::NauticalMiles:
80 case Qgis::DistanceUnit::Yards:
81 case Qgis::DistanceUnit::Miles:
82 case Qgis::DistanceUnit::Kilometers:
83 case Qgis::DistanceUnit::Centimeters:
84 case Qgis::DistanceUnit::Millimeters:
85 case Qgis::DistanceUnit::Inches:
86 case Qgis::DistanceUnit::ChainsInternational:
87 case Qgis::DistanceUnit::ChainsBritishBenoit1895A:
88 case Qgis::DistanceUnit::ChainsBritishBenoit1895B:
89 case Qgis::DistanceUnit::ChainsBritishSears1922Truncated:
90 case Qgis::DistanceUnit::ChainsBritishSears1922:
91 case Qgis::DistanceUnit::ChainsClarkes:
92 case Qgis::DistanceUnit::ChainsUSSurvey:
93 case Qgis::DistanceUnit::FeetBritish1865:
94 case Qgis::DistanceUnit::FeetBritish1936:
95 case Qgis::DistanceUnit::FeetBritishBenoit1895A:
96 case Qgis::DistanceUnit::FeetBritishBenoit1895B:
97 case Qgis::DistanceUnit::FeetBritishSears1922Truncated:
98 case Qgis::DistanceUnit::FeetBritishSears1922:
99 case Qgis::DistanceUnit::FeetClarkes:
100 case Qgis::DistanceUnit::FeetGoldCoast:
101 case Qgis::DistanceUnit::FeetIndian:
102 case Qgis::DistanceUnit::FeetIndian1937:
103 case Qgis::DistanceUnit::FeetIndian1962:
104 case Qgis::DistanceUnit::FeetIndian1975:
105 case Qgis::DistanceUnit::FeetUSSurvey:
106 case Qgis::DistanceUnit::LinksInternational:
107 case Qgis::DistanceUnit::LinksBritishBenoit1895A:
108 case Qgis::DistanceUnit::LinksBritishBenoit1895B:
109 case Qgis::DistanceUnit::LinksBritishSears1922Truncated:
110 case Qgis::DistanceUnit::LinksBritishSears1922:
111 case Qgis::DistanceUnit::LinksClarkes:
112 case Qgis::DistanceUnit::LinksUSSurvey:
113 case Qgis::DistanceUnit::YardsBritishBenoit1895A:
114 case Qgis::DistanceUnit::YardsBritishBenoit1895B:
115 case Qgis::DistanceUnit::YardsBritishSears1922Truncated:
116 case Qgis::DistanceUnit::YardsBritishSears1922:
117 case Qgis::DistanceUnit::YardsClarkes:
118 case Qgis::DistanceUnit::YardsIndian:
119 case Qgis::DistanceUnit::YardsIndian1937:
120 case Qgis::DistanceUnit::YardsIndian1962:
121 case Qgis::DistanceUnit::YardsIndian1975:
122 case Qgis::DistanceUnit::MilesUSSurvey:
123 case Qgis::DistanceUnit::Fathoms:
124 case Qgis::DistanceUnit::MetersGermanLegal:
125 return Qgis::DistanceUnitType::Standard;
126
127 case Qgis::DistanceUnit::Degrees:
128 return Qgis::DistanceUnitType::Geographic;
129
130 case Qgis::DistanceUnit::Unknown:
131 return Qgis::DistanceUnitType::Unknown;
132 }
133 return Qgis::DistanceUnitType::Unknown;
134}
135
162
163QString QgsUnitTypes::encodeUnit( Qgis::DistanceUnit unit )
164{
165 switch ( unit )
166 {
167 case Qgis::DistanceUnit::Meters:
168 return QStringLiteral( "meters" );
169
170 case Qgis::DistanceUnit::Kilometers:
171 return QStringLiteral( "km" );
172
173 case Qgis::DistanceUnit::Feet:
174 return QStringLiteral( "feet" );
175
176 case Qgis::DistanceUnit::Yards:
177 return QStringLiteral( "yd" );
178
179 case Qgis::DistanceUnit::Miles:
180 return QStringLiteral( "mi" );
181
182 case Qgis::DistanceUnit::Degrees:
183 return QStringLiteral( "degrees" );
184
185 case Qgis::DistanceUnit::Unknown:
186 return QStringLiteral( "<unknown>" );
187
188 case Qgis::DistanceUnit::NauticalMiles:
189 return QStringLiteral( "nautical miles" );
190
191 case Qgis::DistanceUnit::Centimeters:
192 return QStringLiteral( "cm" );
193
194 case Qgis::DistanceUnit::Millimeters:
195 return QStringLiteral( "mm" );
196
197 case Qgis::DistanceUnit::Inches:
198 return QStringLiteral( "in" );
199
200 case Qgis::DistanceUnit::ChainsInternational:
201 return QStringLiteral( "chain" );
202
203 case Qgis::DistanceUnit::ChainsBritishBenoit1895A:
204 return QStringLiteral( "chain british benoit b1895a" );
205
206 case Qgis::DistanceUnit::ChainsBritishBenoit1895B:
207 return QStringLiteral( "chain british benoit b1895b" );
208
209 case Qgis::DistanceUnit::ChainsBritishSears1922Truncated:
210 return QStringLiteral( "chain british sears 1922 truncated" );
211
212 case Qgis::DistanceUnit::ChainsBritishSears1922:
213 return QStringLiteral( "chain british sears 1922" );
214
215 case Qgis::DistanceUnit::ChainsClarkes:
216 return QStringLiteral( "chain clarkes" );
217
218 case Qgis::DistanceUnit::ChainsUSSurvey:
219 return QStringLiteral( "chain us survey" );
220
221 case Qgis::DistanceUnit::FeetBritish1865:
222 return QStringLiteral( "feet british 1865" );
223
224 case Qgis::DistanceUnit::FeetBritish1936:
225 return QStringLiteral( "feet british 1936" );
226
227 case Qgis::DistanceUnit::FeetBritishBenoit1895A:
228 return QStringLiteral( "feet british benoit 1895a" );
229
230 case Qgis::DistanceUnit::FeetBritishBenoit1895B:
231 return QStringLiteral( "feet british benoit 1895b" );
232
233 case Qgis::DistanceUnit::FeetBritishSears1922Truncated:
234 return QStringLiteral( "feet british sears 1922 truncated" );
235
236 case Qgis::DistanceUnit::FeetBritishSears1922:
237 return QStringLiteral( "feet british sears 1922" );
238
239 case Qgis::DistanceUnit::FeetClarkes:
240 return QStringLiteral( "feet clarkes" );
241
242 case Qgis::DistanceUnit::FeetGoldCoast:
243 return QStringLiteral( "feet gold coast" );
244
245 case Qgis::DistanceUnit::FeetIndian:
246 return QStringLiteral( "feet indian" );
247 case Qgis::DistanceUnit::FeetIndian1937:
248 return QStringLiteral( "feet indian 1937" );
249
250 case Qgis::DistanceUnit::FeetIndian1962:
251 return QStringLiteral( "feet indian 1962" );
252
253 case Qgis::DistanceUnit::FeetIndian1975:
254 return QStringLiteral( "feet indian 1975" );
255
256 case Qgis::DistanceUnit::FeetUSSurvey:
257 return QStringLiteral( "feet us survey" );
258
259 case Qgis::DistanceUnit::LinksInternational:
260 return QStringLiteral( "links" );
261
262 case Qgis::DistanceUnit::LinksBritishBenoit1895A:
263 return QStringLiteral( "links british benoit 1895a" );
264
265 case Qgis::DistanceUnit::LinksBritishBenoit1895B:
266 return QStringLiteral( "links british benoit 1895b" );
267
268 case Qgis::DistanceUnit::LinksBritishSears1922Truncated:
269 return QStringLiteral( "links british sears 1922 truncated" );
270
271 case Qgis::DistanceUnit::LinksBritishSears1922:
272 return QStringLiteral( "links british sears 1922" );
273
274 case Qgis::DistanceUnit::LinksClarkes:
275 return QStringLiteral( "links clarkes" );
276
277 case Qgis::DistanceUnit::LinksUSSurvey:
278 return QStringLiteral( "links us survey" );
279
280 case Qgis::DistanceUnit::YardsBritishBenoit1895A:
281 return QStringLiteral( "yards british benoit 1895a" );
282
283 case Qgis::DistanceUnit::YardsBritishBenoit1895B:
284 return QStringLiteral( "yards british benoit 1895b" );
285
286 case Qgis::DistanceUnit::YardsBritishSears1922Truncated:
287 return QStringLiteral( "yards british sears 1922 truncated" );
288
289 case Qgis::DistanceUnit::YardsBritishSears1922:
290 return QStringLiteral( "yards british sears 1922" );
291
292 case Qgis::DistanceUnit::YardsClarkes:
293 return QStringLiteral( "yards clarkes" );
294
295 case Qgis::DistanceUnit::YardsIndian:
296 return QStringLiteral( "yards indian" );
297
298 case Qgis::DistanceUnit::YardsIndian1937:
299 return QStringLiteral( "yards indian 1937" );
300
301 case Qgis::DistanceUnit::YardsIndian1962:
302 return QStringLiteral( "yards indian 1962" );
303
304 case Qgis::DistanceUnit::YardsIndian1975:
305 return QStringLiteral( "yards indian 1975" );
306
307 case Qgis::DistanceUnit::MilesUSSurvey:
308 return QStringLiteral( "miles us survey" );
309
310 case Qgis::DistanceUnit::Fathoms:
311 return QStringLiteral( "yards fathom" );
312
313 case Qgis::DistanceUnit::MetersGermanLegal:
314 return QStringLiteral( "german legal meters" );
315 }
316 return QString();
317}
318
319/***************************************************************************
320 * This class is considered CRITICAL and any change MUST be accompanied with
321 * full unit tests in test_qgsunittypes.py.
322 * See details in QEP #17
323 ****************************************************************************/
324
325Qgis::DistanceUnit QgsUnitTypes::decodeDistanceUnit( const QString &string, bool *ok )
326{
327 const QString normalized = string.trimmed().toLower();
328
329 if ( ok )
330 *ok = true;
331
332 for ( const Qgis::DistanceUnit unit :
333 {
334 Qgis::DistanceUnit::Meters,
335 Qgis::DistanceUnit::Feet,
336 Qgis::DistanceUnit::Degrees,
337 Qgis::DistanceUnit::NauticalMiles,
338 Qgis::DistanceUnit::Kilometers,
339 Qgis::DistanceUnit::Yards,
340 Qgis::DistanceUnit::Miles,
341 Qgis::DistanceUnit::Centimeters,
342 Qgis::DistanceUnit::Millimeters,
343 Qgis::DistanceUnit::Inches,
344 Qgis::DistanceUnit::Unknown,
345
346 Qgis::DistanceUnit::ChainsInternational,
347 Qgis::DistanceUnit::ChainsBritishBenoit1895A,
348 Qgis::DistanceUnit::ChainsBritishBenoit1895B,
349 Qgis::DistanceUnit::ChainsBritishSears1922Truncated,
350 Qgis::DistanceUnit::ChainsBritishSears1922,
351 Qgis::DistanceUnit::ChainsClarkes,
352 Qgis::DistanceUnit::ChainsUSSurvey,
353 Qgis::DistanceUnit::FeetBritish1865,
354 Qgis::DistanceUnit::FeetBritish1936,
355 Qgis::DistanceUnit::FeetBritishBenoit1895A,
356 Qgis::DistanceUnit::FeetBritishBenoit1895B,
357 Qgis::DistanceUnit::FeetBritishSears1922Truncated,
358 Qgis::DistanceUnit::FeetBritishSears1922,
359 Qgis::DistanceUnit::FeetClarkes,
360 Qgis::DistanceUnit::FeetGoldCoast,
361 Qgis::DistanceUnit::FeetIndian,
362 Qgis::DistanceUnit::FeetIndian1937,
363 Qgis::DistanceUnit::FeetIndian1962,
364 Qgis::DistanceUnit::FeetIndian1975,
365 Qgis::DistanceUnit::FeetUSSurvey,
366 Qgis::DistanceUnit::LinksInternational,
367 Qgis::DistanceUnit::LinksBritishBenoit1895A,
368 Qgis::DistanceUnit::LinksBritishBenoit1895B,
369 Qgis::DistanceUnit::LinksBritishSears1922Truncated,
370 Qgis::DistanceUnit::LinksBritishSears1922,
371 Qgis::DistanceUnit::LinksClarkes,
372 Qgis::DistanceUnit::LinksUSSurvey,
373 Qgis::DistanceUnit::YardsBritishBenoit1895A,
374 Qgis::DistanceUnit::YardsBritishBenoit1895B,
375 Qgis::DistanceUnit::YardsBritishSears1922Truncated,
376 Qgis::DistanceUnit::YardsBritishSears1922,
377 Qgis::DistanceUnit::YardsClarkes,
378 Qgis::DistanceUnit::YardsIndian,
379 Qgis::DistanceUnit::YardsIndian1937,
380 Qgis::DistanceUnit::YardsIndian1962,
381 Qgis::DistanceUnit::YardsIndian1975,
382 Qgis::DistanceUnit::MilesUSSurvey,
383 Qgis::DistanceUnit::Fathoms,
384 Qgis::DistanceUnit::MetersGermanLegal,
385 } )
386 {
387 if ( normalized == encodeUnit( unit ) )
388 return unit;
389 }
390 if ( ok )
391 *ok = false;
392
393 return Qgis::DistanceUnit::Unknown;
394}
395
396QString QgsUnitTypes::toString( Qgis::DistanceUnit unit )
397{
398 switch ( unit )
399 {
400 case Qgis::DistanceUnit::Meters:
401 return QObject::tr( "meters", "distance" );
402
403 case Qgis::DistanceUnit::Kilometers:
404 return QObject::tr( "kilometers", "distance" );
405
406 case Qgis::DistanceUnit::Feet:
407 return QObject::tr( "feet", "distance" );
408
409 case Qgis::DistanceUnit::Yards:
410 return QObject::tr( "yards", "distance" );
411
412 case Qgis::DistanceUnit::Miles:
413 return QObject::tr( "miles", "distance" );
414
415 case Qgis::DistanceUnit::Degrees:
416 return QObject::tr( "degrees", "distance" );
417
418 case Qgis::DistanceUnit::Centimeters:
419 return QObject::tr( "centimeters", "distance" );
420
421 case Qgis::DistanceUnit::Millimeters:
422 return QObject::tr( "millimeters", "distance" );
423
424 case Qgis::DistanceUnit::Inches:
425 return QObject::tr( "inches", "distance" );
426
427 case Qgis::DistanceUnit::Unknown:
428 return QObject::tr( "<unknown>", "distance" );
429
430 case Qgis::DistanceUnit::NauticalMiles:
431 return QObject::tr( "nautical miles", "distance" );
432
433 case Qgis::DistanceUnit::ChainsInternational:
434 return QObject::tr( "chains (international)", "distance" );
435
436 case Qgis::DistanceUnit::ChainsBritishBenoit1895A:
437 return QObject::tr( "chains (British, Benoit 1895 A)", "distance" );
438
439 case Qgis::DistanceUnit::ChainsBritishBenoit1895B:
440 return QObject::tr( "chains (British, Benoit 1895 B)", "distance" );
441
442 case Qgis::DistanceUnit::ChainsBritishSears1922Truncated:
443 return QObject::tr( "chains (British, Sears 1922 truncated)", "distance" );
444
445 case Qgis::DistanceUnit::ChainsBritishSears1922:
446 return QObject::tr( "chains (British, Sears 1922)", "distance" );
447
448 case Qgis::DistanceUnit::ChainsClarkes:
449 return QObject::tr( "chains (Clarke's)", "distance" );
450
451 case Qgis::DistanceUnit::ChainsUSSurvey:
452 return QObject::tr( "chains (US survey)", "distance" );
453
454 case Qgis::DistanceUnit::FeetBritish1865:
455 return QObject::tr( "feet (British, 1865)", "distance" );
456
457 case Qgis::DistanceUnit::FeetBritish1936:
458 return QObject::tr( "feet (British, 1936)", "distance" );
459
460 case Qgis::DistanceUnit::FeetBritishBenoit1895A:
461 return QObject::tr( "feet (British, Benoit 1895 A)", "distance" );
462
463 case Qgis::DistanceUnit::FeetBritishBenoit1895B:
464 return QObject::tr( "feet (British, Benoit 1895 B)", "distance" );
465
466 case Qgis::DistanceUnit::FeetBritishSears1922Truncated:
467 return QObject::tr( "feet (British, Sears 1922 truncated)", "distance" );
468
469 case Qgis::DistanceUnit::FeetBritishSears1922:
470 return QObject::tr( "feet (British, Sears 1922)", "distance" );
471
472 case Qgis::DistanceUnit::FeetClarkes:
473 return QObject::tr( "feet (Clarke's)", "distance" );
474
475 case Qgis::DistanceUnit::FeetGoldCoast:
476 return QObject::tr( "feet (Gold Coast)", "distance" );
477
478 case Qgis::DistanceUnit::FeetIndian:
479 return QObject::tr( "feet (Indian)", "distance" );
480
481 case Qgis::DistanceUnit::FeetIndian1937:
482 return QObject::tr( "feet (Indian 1937)", "distance" );
483
484 case Qgis::DistanceUnit::FeetIndian1962:
485 return QObject::tr( "feet (Indian 1962)", "distance" );
486
487 case Qgis::DistanceUnit::FeetIndian1975:
488 return QObject::tr( "feet (Indian 1975)", "distance" );
489
490 case Qgis::DistanceUnit::FeetUSSurvey:
491 return QObject::tr( "feet (US survey)", "distance" );
492
493 case Qgis::DistanceUnit::LinksInternational:
494 return QObject::tr( "links", "distance" );
495
496 case Qgis::DistanceUnit::LinksBritishBenoit1895A:
497 return QObject::tr( "links (British, Benoit 1895 A)", "distance" );
498
499 case Qgis::DistanceUnit::LinksBritishBenoit1895B:
500 return QObject::tr( "links (British, Benoit 1895 B)", "distance" );
501
502 case Qgis::DistanceUnit::LinksBritishSears1922Truncated:
503 return QObject::tr( "links (British, Sears 1922 truncated)", "distance" );
504
505 case Qgis::DistanceUnit::LinksBritishSears1922:
506 return QObject::tr( "links (British, Sears 1922)", "distance" );
507
508 case Qgis::DistanceUnit::LinksClarkes:
509 return QObject::tr( "links (Clarke's)", "distance" );
510
511 case Qgis::DistanceUnit::LinksUSSurvey:
512 return QObject::tr( "links (US survey)", "distance" );
513
514 case Qgis::DistanceUnit::YardsBritishBenoit1895A:
515 return QObject::tr( "yards (British, Benoit 1895 A)", "distance" );
516
517 case Qgis::DistanceUnit::YardsBritishBenoit1895B:
518 return QObject::tr( "yards (British, Benoit 1895 B)", "distance" );
519
520 case Qgis::DistanceUnit::YardsBritishSears1922Truncated:
521 return QObject::tr( "yards (British, Sears 1922 truncated)", "distance" );
522
523 case Qgis::DistanceUnit::YardsBritishSears1922:
524 return QObject::tr( "yards (British, Sears 1922)", "distance" );
525
526 case Qgis::DistanceUnit::YardsClarkes:
527 return QObject::tr( "yards (Clarke's)", "distance" );
528
529 case Qgis::DistanceUnit::YardsIndian:
530 return QObject::tr( "yards (Indian)", "distance" );
531
532 case Qgis::DistanceUnit::YardsIndian1937:
533 return QObject::tr( "yards (Indian 1937)", "distance" );
534
535 case Qgis::DistanceUnit::YardsIndian1962:
536 return QObject::tr( "yards (Indian 1962)", "distance" );
537
538 case Qgis::DistanceUnit::YardsIndian1975:
539 return QObject::tr( "yards (Indian 1975)", "distance" );
540
541 case Qgis::DistanceUnit::MilesUSSurvey:
542 return QObject::tr( "miles (US survey)", "distance" );
543
544 case Qgis::DistanceUnit::Fathoms:
545 return QObject::tr( "fathoms", "distance" );
546
547 case Qgis::DistanceUnit::MetersGermanLegal:
548 return QObject::tr( "meters (German legal)", "distance" );
549 }
550 return QString();
551}
552
553QString QgsUnitTypes::toAbbreviatedString( Qgis::RenderUnit unit )
554{
555 switch ( unit )
556 {
557 case Qgis::RenderUnit::Millimeters:
558 return QObject::tr( "mm", "render" );
559
560 case Qgis::RenderUnit::MapUnits:
561 return QObject::tr( "map units", "render" );
562
563 case Qgis::RenderUnit::Pixels:
564 return QObject::tr( "px", "render" );
565
566 case Qgis::RenderUnit::Percentage:
567 return QObject::tr( "%", "render" );
568
569 case Qgis::RenderUnit::Points:
570 return QObject::tr( "pt", "render" );
571
572 case Qgis::RenderUnit::Inches:
573 return QObject::tr( "in", "render" );
574
575 case Qgis::RenderUnit::Unknown:
576 return QObject::tr( "unknown", "render" );
577
578 case Qgis::RenderUnit::MetersInMapUnits:
579 return QObject::tr( "m", "render" );
580
581 }
582
583 return QString();
584}
585
586QString QgsUnitTypes::toAbbreviatedString( Qgis::DistanceUnit unit )
587{
588 switch ( unit )
589 {
590 case Qgis::DistanceUnit::Meters:
591 return QObject::tr( "m", "distance" );
592
593 case Qgis::DistanceUnit::Kilometers:
594 return QObject::tr( "km", "distance" );
595
596 case Qgis::DistanceUnit::Feet:
597 case Qgis::DistanceUnit::FeetBritish1865:
598 case Qgis::DistanceUnit::FeetBritish1936:
599 case Qgis::DistanceUnit::FeetBritishBenoit1895A:
600 case Qgis::DistanceUnit::FeetBritishBenoit1895B:
601 case Qgis::DistanceUnit::FeetBritishSears1922Truncated:
602 case Qgis::DistanceUnit::FeetBritishSears1922:
603 case Qgis::DistanceUnit::FeetClarkes:
604 case Qgis::DistanceUnit::FeetGoldCoast:
605 case Qgis::DistanceUnit::FeetIndian:
606 case Qgis::DistanceUnit::FeetIndian1937:
607 case Qgis::DistanceUnit::FeetIndian1962:
608 case Qgis::DistanceUnit::FeetIndian1975:
609 case Qgis::DistanceUnit::FeetUSSurvey:
610 return QObject::tr( "ft", "distance" );
611
612 case Qgis::DistanceUnit::Yards:
613 case Qgis::DistanceUnit::YardsBritishBenoit1895A:
614 case Qgis::DistanceUnit::YardsBritishBenoit1895B:
615 case Qgis::DistanceUnit::YardsBritishSears1922Truncated:
616 case Qgis::DistanceUnit::YardsBritishSears1922:
617 case Qgis::DistanceUnit::YardsClarkes:
618 case Qgis::DistanceUnit::YardsIndian:
619 case Qgis::DistanceUnit::YardsIndian1937:
620 case Qgis::DistanceUnit::YardsIndian1962:
621 case Qgis::DistanceUnit::YardsIndian1975:
622 return QObject::tr( "yd", "distance" );
623
624 case Qgis::DistanceUnit::Miles:
625 case Qgis::DistanceUnit::MilesUSSurvey:
626 return QObject::tr( "mi", "distance" );
627
628 case Qgis::DistanceUnit::Degrees:
629 return QObject::tr( "deg", "distance" );
630
631 case Qgis::DistanceUnit::Centimeters:
632 return QObject::tr( "cm", "distance" );
633
634 case Qgis::DistanceUnit::Millimeters:
635 return QObject::tr( "mm", "distance" );
636
637 case Qgis::DistanceUnit::Inches:
638 return QObject::tr( "in", "distance" );
639
640 case Qgis::DistanceUnit::Unknown:
641 return QString();
642
643 case Qgis::DistanceUnit::NauticalMiles:
644 return QObject::tr( "NM", "distance" );
645
646 case Qgis::DistanceUnit::ChainsInternational:
647 case Qgis::DistanceUnit::ChainsBritishBenoit1895A:
648 case Qgis::DistanceUnit::ChainsBritishBenoit1895B:
649 case Qgis::DistanceUnit::ChainsBritishSears1922Truncated:
650 case Qgis::DistanceUnit::ChainsBritishSears1922:
651 case Qgis::DistanceUnit::ChainsClarkes:
652 case Qgis::DistanceUnit::ChainsUSSurvey:
653 return QObject::tr( "ch", "distance" );
654
655 case Qgis::DistanceUnit::LinksInternational:
656 case Qgis::DistanceUnit::LinksBritishBenoit1895A:
657 case Qgis::DistanceUnit::LinksBritishBenoit1895B:
658 case Qgis::DistanceUnit::LinksBritishSears1922Truncated:
659 case Qgis::DistanceUnit::LinksBritishSears1922:
660 case Qgis::DistanceUnit::LinksClarkes:
661 case Qgis::DistanceUnit::LinksUSSurvey:
662 return QObject::tr( "lk", "distance" );
663
664 case Qgis::DistanceUnit::Fathoms:
665 return QObject::tr( "f", "distance" );
666
667 case Qgis::DistanceUnit::MetersGermanLegal:
668 return QObject::tr( "glm", "distance" );
669
670 }
671 return QString();
672}
673
674/***************************************************************************
675 * This class is considered CRITICAL and any change MUST be accompanied with
676 * full unit tests in test_qgsunittypes.py.
677 * See details in QEP #17
678 ****************************************************************************/
679
680Qgis::DistanceUnit QgsUnitTypes::stringToDistanceUnit( const QString &string, bool *ok )
681{
682 const QString normalized = string.trimmed().toLower();
683
684 if ( ok )
685 *ok = true;
686
687 for ( const Qgis::DistanceUnit unit :
688 {
689 Qgis::DistanceUnit::Meters,
690 Qgis::DistanceUnit::Feet,
691 Qgis::DistanceUnit::Degrees,
692 Qgis::DistanceUnit::NauticalMiles,
693 Qgis::DistanceUnit::Kilometers,
694 Qgis::DistanceUnit::Yards,
695 Qgis::DistanceUnit::Miles,
696 Qgis::DistanceUnit::Centimeters,
697 Qgis::DistanceUnit::Millimeters,
698 Qgis::DistanceUnit::Inches,
699 Qgis::DistanceUnit::Unknown,
700 Qgis::DistanceUnit::ChainsInternational,
701 Qgis::DistanceUnit::ChainsBritishBenoit1895A,
702 Qgis::DistanceUnit::ChainsBritishBenoit1895B,
703 Qgis::DistanceUnit::ChainsBritishSears1922Truncated,
704 Qgis::DistanceUnit::ChainsBritishSears1922,
705 Qgis::DistanceUnit::ChainsClarkes,
706 Qgis::DistanceUnit::ChainsUSSurvey,
707 Qgis::DistanceUnit::FeetBritish1865,
708 Qgis::DistanceUnit::FeetBritish1936,
709 Qgis::DistanceUnit::FeetBritishBenoit1895A,
710 Qgis::DistanceUnit::FeetBritishBenoit1895B,
711 Qgis::DistanceUnit::FeetBritishSears1922Truncated,
712 Qgis::DistanceUnit::FeetBritishSears1922,
713 Qgis::DistanceUnit::FeetClarkes,
714 Qgis::DistanceUnit::FeetGoldCoast,
715 Qgis::DistanceUnit::FeetIndian,
716 Qgis::DistanceUnit::FeetIndian1937,
717 Qgis::DistanceUnit::FeetIndian1962,
718 Qgis::DistanceUnit::FeetIndian1975,
719 Qgis::DistanceUnit::FeetUSSurvey,
720 Qgis::DistanceUnit::LinksInternational,
721 Qgis::DistanceUnit::LinksBritishBenoit1895A,
722 Qgis::DistanceUnit::LinksBritishBenoit1895B,
723 Qgis::DistanceUnit::LinksBritishSears1922Truncated,
724 Qgis::DistanceUnit::LinksBritishSears1922,
725 Qgis::DistanceUnit::LinksClarkes,
726 Qgis::DistanceUnit::LinksUSSurvey,
727 Qgis::DistanceUnit::YardsBritishBenoit1895A,
728 Qgis::DistanceUnit::YardsBritishBenoit1895B,
729 Qgis::DistanceUnit::YardsBritishSears1922Truncated,
730 Qgis::DistanceUnit::YardsBritishSears1922,
731 Qgis::DistanceUnit::YardsClarkes,
732 Qgis::DistanceUnit::YardsIndian,
733 Qgis::DistanceUnit::YardsIndian1937,
734 Qgis::DistanceUnit::YardsIndian1962,
735 Qgis::DistanceUnit::YardsIndian1975,
736 Qgis::DistanceUnit::MilesUSSurvey,
737 Qgis::DistanceUnit::Fathoms,
738 Qgis::DistanceUnit::MetersGermanLegal,
739 } )
740 {
741 if ( normalized.compare( toString( unit ), Qt::CaseInsensitive ) == 0 )
742 return unit;
743 }
744
745 if ( ok )
746 *ok = false;
747
748 return Qgis::DistanceUnit::Unknown;
749}
750
751/***************************************************************************
752 * This class is considered CRITICAL and any change MUST be accompanied with
753 * full unit tests in test_qgsunittypes.py.
754 * See details in QEP #17
755 ****************************************************************************/
756
757constexpr double distanceUnitToMeter( Qgis::DistanceUnit unit )
758{
759 // values are from the EPSG units database:
760 switch ( unit )
761 {
762 case Qgis::DistanceUnit::Meters:
763 return 1.0;
764 case Qgis::DistanceUnit::Kilometers:
765 return 1000.0;
766 case Qgis::DistanceUnit::Feet:
767 return 0.3048;
768 case Qgis::DistanceUnit::NauticalMiles:
769 return 1852.0;
770 case Qgis::DistanceUnit::Yards:
771 return 0.9144;
772 case Qgis::DistanceUnit::Miles:
773 return 1609.344;
774 case Qgis::DistanceUnit::Degrees:
775 return 111319.49079327358;
776 case Qgis::DistanceUnit::Centimeters:
777 return 0.01;
778 case Qgis::DistanceUnit::Millimeters:
779 return 0.001;
780 case Qgis::DistanceUnit::Inches:
781 return 0.0254;
782 case Qgis::DistanceUnit::ChainsInternational:
783 return 20.1168;
784 case Qgis::DistanceUnit::ChainsBritishBenoit1895A:
785 return 20.1167824;
786 case Qgis::DistanceUnit::ChainsBritishBenoit1895B:
787 return 20.116782494376;
788 case Qgis::DistanceUnit::ChainsBritishSears1922Truncated:
789 return 20.116756;
790 case Qgis::DistanceUnit::ChainsBritishSears1922:
791 return 20.116765121553;
792 case Qgis::DistanceUnit::ChainsClarkes:
793 return 20.1166195164;
794 case Qgis::DistanceUnit::ChainsUSSurvey:
795 return 20.11684023368;
796 case Qgis::DistanceUnit::FeetBritish1865:
797 return 0.30480083333333;
798 case Qgis::DistanceUnit::FeetBritish1936:
799 return 0.3048007491;
800 case Qgis::DistanceUnit::FeetBritishBenoit1895A:
801 return 0.30479973333333;
802 case Qgis::DistanceUnit::FeetBritishBenoit1895B:
803 return 0.30479973476327;
804 case Qgis::DistanceUnit::FeetBritishSears1922Truncated:
805 return 0.30479933333333;
806 case Qgis::DistanceUnit::FeetBritishSears1922:
807 return 0.30479947153868;
808 case Qgis::DistanceUnit::FeetClarkes:
809 return 0.3047972654;
810 case Qgis::DistanceUnit::FeetGoldCoast:
811 return 0.30479971018151;
812 case Qgis::DistanceUnit::FeetIndian:
813 return 0.30479951024815;
814 case Qgis::DistanceUnit::FeetIndian1937:
815 return 0.30479841;
816 case Qgis::DistanceUnit::FeetIndian1962:
817 return 0.3047996;
818 case Qgis::DistanceUnit::FeetIndian1975:
819 return 0.3047995;
820 case Qgis::DistanceUnit::FeetUSSurvey:
821 return 0.30480060960122;
822 case Qgis::DistanceUnit::LinksInternational:
823 return 0.201168;
824 case Qgis::DistanceUnit::LinksBritishBenoit1895A:
825 return 0.201167824;
826 case Qgis::DistanceUnit::LinksBritishBenoit1895B:
827 return 0.20116782494376;
828 case Qgis::DistanceUnit::LinksBritishSears1922Truncated:
829 return 0.20116756;
830 case Qgis::DistanceUnit::LinksBritishSears1922:
831 return 0.20116765121553;
832 case Qgis::DistanceUnit::LinksClarkes:
833 return 0.201166195164;
834 case Qgis::DistanceUnit::LinksUSSurvey:
835 return 0.2011684023368;
836 case Qgis::DistanceUnit::YardsBritishBenoit1895A:
837 return 0.9143992;
838 case Qgis::DistanceUnit::YardsBritishBenoit1895B:
839 return 0.91439920428981;
840 case Qgis::DistanceUnit::YardsBritishSears1922Truncated:
841 return 0.914398;
842 case Qgis::DistanceUnit::YardsBritishSears1922:
843 return 0.91439841461603;
844 case Qgis::DistanceUnit::YardsClarkes:
845 return 0.9143917962;
846 case Qgis::DistanceUnit::YardsIndian:
847 return 0.91439853074444;
848 case Qgis::DistanceUnit::YardsIndian1937:
849 return 0.91439523;
850 case Qgis::DistanceUnit::YardsIndian1962:
851 return 0.9143988;
852 case Qgis::DistanceUnit::YardsIndian1975:
853 return 0.9143985;
854 case Qgis::DistanceUnit::MilesUSSurvey:
855 return 1609.3472186944;
856 case Qgis::DistanceUnit::Fathoms:
857 return 1.8288;
858 case Qgis::DistanceUnit::Unknown:
859 return 1;
860 case Qgis::DistanceUnit::MetersGermanLegal:
861 return 1.0000135965;
862 }
863 return 1;
864}
865
866double QgsUnitTypes::fromUnitToUnitFactor( Qgis::DistanceUnit fromUnit, Qgis::DistanceUnit toUnit )
867{
868 if ( fromUnit == toUnit || fromUnit == Qgis::DistanceUnit::Unknown || toUnit == Qgis::DistanceUnit::Unknown )
869 return 1.0;
870
871 constexpr double FEET_TO_INCHES = 12;
872 constexpr double YARDS_TO_FEET = 3.0;
873
874 // Calculate the conversion factor between the specified units
875
876 // special cases, where we don't go through meters as an intermediate unit:
877 switch ( fromUnit )
878 {
879 case Qgis::DistanceUnit::Feet:
880 {
881 switch ( toUnit )
882 {
883 case Qgis::DistanceUnit::Inches:
884 return FEET_TO_INCHES;
885 case Qgis::DistanceUnit::Yards:
886 return 1.0 / YARDS_TO_FEET;
887 default:
888 break;
889 }
890
891 break;
892 }
893 case Qgis::DistanceUnit::Yards:
894 {
895 switch ( toUnit )
896 {
897 case Qgis::DistanceUnit::Feet:
898 return YARDS_TO_FEET;
899 case Qgis::DistanceUnit::Inches:
900 return YARDS_TO_FEET * FEET_TO_INCHES;
901 default:
902 break;
903 }
904
905 break;
906 }
907
908 case Qgis::DistanceUnit::Inches:
909 {
910 switch ( toUnit )
911 {
912 case Qgis::DistanceUnit::Feet:
913 return 1.0 / FEET_TO_INCHES;
914 case Qgis::DistanceUnit::Yards:
915 return 1.0 / ( YARDS_TO_FEET * FEET_TO_INCHES );
916 default:
917 break;
918 }
919
920 break;
921 }
922
923 default:
924 break;
925 }
926
927 return distanceUnitToMeter( fromUnit ) / distanceUnitToMeter( toUnit );
928}
929
930QString QgsUnitTypes::encodeUnit( Qgis::AreaUnit unit )
931{
932 switch ( unit )
933 {
934 case Qgis::AreaUnit::SquareMeters:
935 return QStringLiteral( "m2" );
936 case Qgis::AreaUnit::SquareKilometers:
937 return QStringLiteral( "km2" );
938 case Qgis::AreaUnit::SquareFeet:
939 return QStringLiteral( "ft2" );
940 case Qgis::AreaUnit::SquareYards:
941 return QStringLiteral( "y2" );
942 case Qgis::AreaUnit::SquareMiles:
943 return QStringLiteral( "mi2" );
944 case Qgis::AreaUnit::Hectares:
945 return QStringLiteral( "ha" );
946 case Qgis::AreaUnit::Acres:
947 return QStringLiteral( "ac" );
948 case Qgis::AreaUnit::SquareNauticalMiles:
949 return QStringLiteral( "nm2" );
950 case Qgis::AreaUnit::SquareDegrees:
951 return QStringLiteral( "deg2" );
952 case Qgis::AreaUnit::SquareCentimeters:
953 return QStringLiteral( "cm2" );
954 case Qgis::AreaUnit::SquareMillimeters:
955 return QStringLiteral( "mm2" );
956 case Qgis::AreaUnit::SquareInches:
957 return QStringLiteral( "in2" );
958 case Qgis::AreaUnit::Unknown:
959 return QStringLiteral( "<unknown>" );
960 }
961 return QString();
962}
963
964Qgis::AreaUnit QgsUnitTypes::decodeAreaUnit( const QString &string, bool *ok )
965{
966 const QString normalized = string.trimmed().toLower();
967
968 if ( ok )
969 *ok = true;
970
971 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareMeters ) )
972 return Qgis::AreaUnit::SquareMeters;
973 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareKilometers ) )
974 return Qgis::AreaUnit::SquareKilometers;
975 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareFeet ) )
976 return Qgis::AreaUnit::SquareFeet;
977 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareYards ) )
978 return Qgis::AreaUnit::SquareYards;
979 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareMiles ) )
980 return Qgis::AreaUnit::SquareMiles;
981 if ( normalized == encodeUnit( Qgis::AreaUnit::Hectares ) )
982 return Qgis::AreaUnit::Hectares;
983 if ( normalized == encodeUnit( Qgis::AreaUnit::Acres ) )
984 return Qgis::AreaUnit::Acres;
985 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareNauticalMiles ) )
986 return Qgis::AreaUnit::SquareNauticalMiles;
987 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareDegrees ) )
988 return Qgis::AreaUnit::SquareDegrees;
989 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareCentimeters ) )
990 return Qgis::AreaUnit::SquareCentimeters;
991 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareMillimeters ) )
992 return Qgis::AreaUnit::SquareMillimeters;
993 if ( normalized == encodeUnit( Qgis::AreaUnit::SquareInches ) )
994 return Qgis::AreaUnit::SquareInches;
995 if ( normalized == encodeUnit( Qgis::AreaUnit::Unknown ) )
996 return Qgis::AreaUnit::Unknown;
997
998 if ( ok )
999 *ok = false;
1000
1001 return Qgis::AreaUnit::Unknown;
1002}
1003
1004QString QgsUnitTypes::toString( Qgis::AreaUnit unit )
1005{
1006 switch ( unit )
1007 {
1008 case Qgis::AreaUnit::SquareMeters:
1009 return QObject::tr( "square meters", "area" );
1010 case Qgis::AreaUnit::SquareKilometers:
1011 return QObject::tr( "square kilometers", "area" );
1012 case Qgis::AreaUnit::SquareFeet:
1013 return QObject::tr( "square feet", "area" );
1014 case Qgis::AreaUnit::SquareYards:
1015 return QObject::tr( "square yards", "area" );
1016 case Qgis::AreaUnit::SquareMiles:
1017 return QObject::tr( "square miles", "area" );
1018 case Qgis::AreaUnit::Hectares:
1019 return QObject::tr( "hectares", "area" );
1020 case Qgis::AreaUnit::Acres:
1021 return QObject::tr( "acres", "area" );
1022 case Qgis::AreaUnit::SquareNauticalMiles:
1023 return QObject::tr( "square nautical miles", "area" );
1024 case Qgis::AreaUnit::SquareDegrees:
1025 return QObject::tr( "square degrees", "area" );
1026 case Qgis::AreaUnit::SquareMillimeters:
1027 return QObject::tr( "square millimeters", "area" );
1028 case Qgis::AreaUnit::SquareCentimeters:
1029 return QObject::tr( "square centimeters", "area" );
1030 case Qgis::AreaUnit::SquareInches:
1031 return QObject::tr( "square inches", "area" );
1032 case Qgis::AreaUnit::Unknown:
1033 return QObject::tr( "<unknown>", "area" );
1034 }
1035 return QString();
1036}
1037
1038QString QgsUnitTypes::toAbbreviatedString( Qgis::AreaUnit unit )
1039{
1040 switch ( unit )
1041 {
1042 case Qgis::AreaUnit::SquareMeters:
1043 return QObject::tr( "m²", "area" );
1044 case Qgis::AreaUnit::SquareKilometers:
1045 return QObject::tr( "km²", "area" );
1046 case Qgis::AreaUnit::SquareFeet:
1047 return QObject::tr( "ft²", "area" );
1048 case Qgis::AreaUnit::SquareYards:
1049 return QObject::tr( "yd²", "area" );
1050 case Qgis::AreaUnit::SquareMiles:
1051 return QObject::tr( "mi²", "area" );
1052 case Qgis::AreaUnit::Hectares:
1053 return QObject::tr( "ha", "area" );
1054 case Qgis::AreaUnit::Acres:
1055 return QObject::tr( "ac", "area" );
1056 case Qgis::AreaUnit::SquareNauticalMiles:
1057 return QObject::tr( "NM²", "area" );
1058 case Qgis::AreaUnit::SquareDegrees:
1059 return QObject::tr( "deg²", "area" );
1060 case Qgis::AreaUnit::SquareCentimeters:
1061 return QObject::tr( "cm²", "area" );
1062 case Qgis::AreaUnit::SquareMillimeters:
1063 return QObject::tr( "mm²", "area" );
1064 case Qgis::AreaUnit::SquareInches:
1065 return QObject::tr( "in²", "area" );
1066 case Qgis::AreaUnit::Unknown:
1067 return QString();
1068 }
1069 return QString();
1070}
1071
1072Qgis::AreaUnit QgsUnitTypes::stringToAreaUnit( const QString &string, bool *ok )
1073{
1074 const QString normalized = string.trimmed().toLower();
1075
1076 if ( ok )
1077 *ok = true;
1078
1079 if ( normalized == toString( Qgis::AreaUnit::SquareMeters ) )
1080 return Qgis::AreaUnit::SquareMeters;
1081 if ( normalized == toString( Qgis::AreaUnit::SquareKilometers ) )
1082 return Qgis::AreaUnit::SquareKilometers;
1083 if ( normalized == toString( Qgis::AreaUnit::SquareFeet ) )
1084 return Qgis::AreaUnit::SquareFeet;
1085 if ( normalized == toString( Qgis::AreaUnit::SquareYards ) )
1086 return Qgis::AreaUnit::SquareYards;
1087 if ( normalized == toString( Qgis::AreaUnit::SquareMiles ) )
1088 return Qgis::AreaUnit::SquareMiles;
1089 if ( normalized == toString( Qgis::AreaUnit::Hectares ) )
1090 return Qgis::AreaUnit::Hectares;
1091 if ( normalized == toString( Qgis::AreaUnit::Acres ) )
1092 return Qgis::AreaUnit::Acres;
1093 if ( normalized == toString( Qgis::AreaUnit::SquareNauticalMiles ) )
1094 return Qgis::AreaUnit::SquareNauticalMiles;
1095 if ( normalized == toString( Qgis::AreaUnit::SquareDegrees ) )
1096 return Qgis::AreaUnit::SquareDegrees;
1097 if ( normalized == toString( Qgis::AreaUnit::SquareMillimeters ) )
1098 return Qgis::AreaUnit::SquareMillimeters;
1099 if ( normalized == toString( Qgis::AreaUnit::SquareCentimeters ) )
1100 return Qgis::AreaUnit::SquareCentimeters;
1101 if ( normalized == toString( Qgis::AreaUnit::SquareInches ) )
1102 return Qgis::AreaUnit::SquareInches;
1103 if ( normalized == toString( Qgis::AreaUnit::Unknown ) )
1104 return Qgis::AreaUnit::Unknown;
1105 if ( ok )
1106 *ok = false;
1107
1108 return Qgis::AreaUnit::Unknown;
1109}
1110
1111double QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit fromUnit, Qgis::AreaUnit toUnit )
1112{
1113#define KM2_TO_M2 1000000.0
1114#define CM2_TO_M2 0.0001
1115#define MM2_TO_M2 0.000001
1116#define FT2_TO_M2 0.09290304
1117#define IN2_TO_M2 0.00064516
1118#define YD2_TO_M2 0.83612736
1119#define MI2_TO_M2 2589988.110336
1120#define HA_TO_M2 10000.0
1121#define AC_TO_FT2 43560.0
1122#define DEG2_TO_M2 12392029030.5
1123#define NM2_TO_M2 3429904.0
1124
1125 // Calculate the conversion factor between the specified units
1126 switch ( fromUnit )
1127 {
1128 case Qgis::AreaUnit::SquareMeters:
1129 {
1130 switch ( toUnit )
1131 {
1132 case Qgis::AreaUnit::SquareMeters:
1133 return 1.0;
1134 case Qgis::AreaUnit::SquareKilometers:
1135 return 1.0 / KM2_TO_M2;
1136 case Qgis::AreaUnit::SquareFeet:
1137 return 1.0 / FT2_TO_M2;
1138 case Qgis::AreaUnit::SquareYards:
1139 return 1.0 / YD2_TO_M2;
1140 case Qgis::AreaUnit::SquareMiles:
1141 return 1.0 / MI2_TO_M2;
1142 case Qgis::AreaUnit::Hectares:
1143 return 1.0 / HA_TO_M2;
1144 case Qgis::AreaUnit::Acres:
1145 return 1.0 / AC_TO_FT2 / FT2_TO_M2;
1146 case Qgis::AreaUnit::SquareNauticalMiles:
1147 return 1.0 / NM2_TO_M2;
1148 case Qgis::AreaUnit::SquareDegrees:
1149 return 1.0 / DEG2_TO_M2;
1150 case Qgis::AreaUnit::SquareCentimeters:
1151 return 1.0 / CM2_TO_M2;
1152 case Qgis::AreaUnit::SquareMillimeters:
1153 return 1.0 / MM2_TO_M2;
1154 case Qgis::AreaUnit::SquareInches:
1155 return 1.0 / IN2_TO_M2;
1156 case Qgis::AreaUnit::Unknown:
1157 break;
1158 }
1159
1160 break;
1161 }
1162 case Qgis::AreaUnit::SquareKilometers:
1163 {
1164 switch ( toUnit )
1165 {
1166 case Qgis::AreaUnit::SquareMeters:
1167 return KM2_TO_M2;
1168 case Qgis::AreaUnit::SquareKilometers:
1169 return 1.0;
1170 case Qgis::AreaUnit::SquareFeet:
1171 return KM2_TO_M2 / FT2_TO_M2;
1172 case Qgis::AreaUnit::SquareYards:
1173 return KM2_TO_M2 / YD2_TO_M2;
1174 case Qgis::AreaUnit::SquareMiles:
1175 return KM2_TO_M2 / MI2_TO_M2;
1176 case Qgis::AreaUnit::Hectares:
1177 return KM2_TO_M2 / HA_TO_M2;
1178 case Qgis::AreaUnit::Acres:
1179 return KM2_TO_M2 / AC_TO_FT2 / FT2_TO_M2;
1180 case Qgis::AreaUnit::SquareNauticalMiles:
1181 return KM2_TO_M2 / NM2_TO_M2;
1182 case Qgis::AreaUnit::SquareDegrees:
1183 return KM2_TO_M2 / DEG2_TO_M2;
1184 case Qgis::AreaUnit::SquareCentimeters:
1185 return KM2_TO_M2 / CM2_TO_M2;
1186 case Qgis::AreaUnit::SquareMillimeters:
1187 return KM2_TO_M2 / MM2_TO_M2;
1188 case Qgis::AreaUnit::SquareInches:
1189 return KM2_TO_M2 / IN2_TO_M2;
1190 case Qgis::AreaUnit::Unknown:
1191 break;
1192 }
1193
1194 break;
1195 }
1196 case Qgis::AreaUnit::SquareFeet:
1197 {
1198 switch ( toUnit )
1199 {
1200 case Qgis::AreaUnit::SquareMeters:
1201 return FT2_TO_M2;
1202 case Qgis::AreaUnit::SquareKilometers:
1203 return FT2_TO_M2 / KM2_TO_M2;
1204 case Qgis::AreaUnit::SquareFeet:
1205 return 1.0;
1206 case Qgis::AreaUnit::SquareYards:
1207 return FT2_TO_M2 / YD2_TO_M2;
1208 case Qgis::AreaUnit::SquareMiles:
1209 return FT2_TO_M2 / MI2_TO_M2;
1210 case Qgis::AreaUnit::Hectares:
1211 return FT2_TO_M2 / HA_TO_M2;
1212 case Qgis::AreaUnit::Acres:
1213 return 1.0 / AC_TO_FT2;
1214 case Qgis::AreaUnit::SquareNauticalMiles:
1215 return FT2_TO_M2 / NM2_TO_M2;
1216 case Qgis::AreaUnit::SquareDegrees:
1217 return FT2_TO_M2 / DEG2_TO_M2;
1218 case Qgis::AreaUnit::SquareCentimeters:
1219 return FT2_TO_M2 / CM2_TO_M2;
1220 case Qgis::AreaUnit::SquareMillimeters:
1221 return FT2_TO_M2 / MM2_TO_M2;
1222 case Qgis::AreaUnit::SquareInches:
1223 return FT2_TO_M2 / IN2_TO_M2;
1224 case Qgis::AreaUnit::Unknown:
1225 break;
1226 }
1227
1228 break;
1229 }
1230
1231 case Qgis::AreaUnit::SquareYards:
1232 {
1233 switch ( toUnit )
1234 {
1235 case Qgis::AreaUnit::SquareMeters:
1236 return YD2_TO_M2;
1237 case Qgis::AreaUnit::SquareKilometers:
1238 return YD2_TO_M2 / KM2_TO_M2;
1239 case Qgis::AreaUnit::SquareFeet:
1240 return YD2_TO_M2 / FT2_TO_M2;
1241 case Qgis::AreaUnit::SquareYards:
1242 return 1.0;
1243 case Qgis::AreaUnit::SquareMiles:
1244 return YD2_TO_M2 / MI2_TO_M2;
1245 case Qgis::AreaUnit::Hectares:
1246 return YD2_TO_M2 / HA_TO_M2;
1247 case Qgis::AreaUnit::Acres:
1248 return YD2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
1249 case Qgis::AreaUnit::SquareNauticalMiles:
1250 return YD2_TO_M2 / NM2_TO_M2;
1251 case Qgis::AreaUnit::SquareDegrees:
1252 return YD2_TO_M2 / DEG2_TO_M2;
1253 case Qgis::AreaUnit::SquareCentimeters:
1254 return YD2_TO_M2 / CM2_TO_M2;
1255 case Qgis::AreaUnit::SquareMillimeters:
1256 return YD2_TO_M2 / MM2_TO_M2;
1257 case Qgis::AreaUnit::SquareInches:
1258 return YD2_TO_M2 / IN2_TO_M2;
1259 case Qgis::AreaUnit::Unknown:
1260 break;
1261 }
1262 break;
1263 }
1264
1265 case Qgis::AreaUnit::SquareMiles:
1266 {
1267 switch ( toUnit )
1268 {
1269 case Qgis::AreaUnit::SquareMeters:
1270 return MI2_TO_M2;
1271 case Qgis::AreaUnit::SquareKilometers:
1272 return MI2_TO_M2 / KM2_TO_M2;
1273 case Qgis::AreaUnit::SquareFeet:
1274 return MI2_TO_M2 / FT2_TO_M2;
1275 case Qgis::AreaUnit::SquareYards:
1276 return MI2_TO_M2 / YD2_TO_M2;
1277 case Qgis::AreaUnit::SquareMiles:
1278 return 1.0;
1279 case Qgis::AreaUnit::Hectares:
1280 return MI2_TO_M2 / HA_TO_M2;
1281 case Qgis::AreaUnit::Acres:
1282 return MI2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
1283 case Qgis::AreaUnit::SquareNauticalMiles:
1284 return MI2_TO_M2 / NM2_TO_M2;
1285 case Qgis::AreaUnit::SquareDegrees:
1286 return MI2_TO_M2 / DEG2_TO_M2;
1287 case Qgis::AreaUnit::SquareCentimeters:
1288 return MI2_TO_M2 / CM2_TO_M2;
1289 case Qgis::AreaUnit::SquareMillimeters:
1290 return MI2_TO_M2 / MM2_TO_M2;
1291 case Qgis::AreaUnit::SquareInches:
1292 return MI2_TO_M2 / IN2_TO_M2;
1293 case Qgis::AreaUnit::Unknown:
1294 break;
1295 }
1296
1297 break;
1298 }
1299
1300 case Qgis::AreaUnit::Hectares:
1301 {
1302 switch ( toUnit )
1303 {
1304 case Qgis::AreaUnit::SquareMeters:
1305 return HA_TO_M2;
1306 case Qgis::AreaUnit::SquareKilometers:
1307 return HA_TO_M2 / KM2_TO_M2;
1308 case Qgis::AreaUnit::SquareFeet:
1309 return HA_TO_M2 / FT2_TO_M2;
1310 case Qgis::AreaUnit::SquareYards:
1311 return HA_TO_M2 / YD2_TO_M2;
1312 case Qgis::AreaUnit::SquareMiles:
1313 return HA_TO_M2 / MI2_TO_M2;
1314 case Qgis::AreaUnit::Hectares:
1315 return 1.0;
1316 case Qgis::AreaUnit::Acres:
1317 return HA_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
1318 case Qgis::AreaUnit::SquareNauticalMiles:
1319 return HA_TO_M2 / NM2_TO_M2;
1320 case Qgis::AreaUnit::SquareDegrees:
1321 return HA_TO_M2 / DEG2_TO_M2;
1322 case Qgis::AreaUnit::SquareCentimeters:
1323 return HA_TO_M2 / CM2_TO_M2;
1324 case Qgis::AreaUnit::SquareMillimeters:
1325 return HA_TO_M2 / MM2_TO_M2;
1326 case Qgis::AreaUnit::SquareInches:
1327 return HA_TO_M2 / IN2_TO_M2;
1328 case Qgis::AreaUnit::Unknown:
1329 break;
1330 }
1331
1332 break;
1333 }
1334
1335 case Qgis::AreaUnit::Acres:
1336 {
1337 switch ( toUnit )
1338 {
1339 case Qgis::AreaUnit::SquareMeters:
1340 return AC_TO_FT2 * FT2_TO_M2;
1341 case Qgis::AreaUnit::SquareKilometers:
1342 return AC_TO_FT2 * FT2_TO_M2 / KM2_TO_M2;
1343 case Qgis::AreaUnit::SquareFeet:
1344 return AC_TO_FT2;
1345 case Qgis::AreaUnit::SquareYards:
1346 return AC_TO_FT2 * FT2_TO_M2 / YD2_TO_M2;
1347 case Qgis::AreaUnit::SquareMiles:
1348 return AC_TO_FT2 * FT2_TO_M2 / MI2_TO_M2;
1349 case Qgis::AreaUnit::Hectares:
1350 return AC_TO_FT2 * FT2_TO_M2 / HA_TO_M2;
1351 case Qgis::AreaUnit::Acres:
1352 return 1.0;
1353 case Qgis::AreaUnit::SquareNauticalMiles:
1354 return AC_TO_FT2 * FT2_TO_M2 / NM2_TO_M2;
1355 case Qgis::AreaUnit::SquareDegrees:
1356 return AC_TO_FT2 * FT2_TO_M2 / DEG2_TO_M2;
1357 case Qgis::AreaUnit::SquareCentimeters:
1358 return AC_TO_FT2 * FT2_TO_M2 / CM2_TO_M2;
1359 case Qgis::AreaUnit::SquareMillimeters:
1360 return AC_TO_FT2 * FT2_TO_M2 / MM2_TO_M2;
1361 case Qgis::AreaUnit::SquareInches:
1362 return AC_TO_FT2 * FT2_TO_M2 / IN2_TO_M2;
1363 case Qgis::AreaUnit::Unknown:
1364 break;
1365 }
1366
1367 break;
1368 }
1369
1370 case Qgis::AreaUnit::SquareNauticalMiles:
1371 {
1372 switch ( toUnit )
1373 {
1374 case Qgis::AreaUnit::SquareMeters:
1375 return NM2_TO_M2;
1376 case Qgis::AreaUnit::SquareKilometers:
1377 return NM2_TO_M2 / KM2_TO_M2;
1378 case Qgis::AreaUnit::SquareFeet:
1379 return NM2_TO_M2 / FT2_TO_M2;
1380 case Qgis::AreaUnit::SquareYards:
1381 return NM2_TO_M2 / YD2_TO_M2;
1382 case Qgis::AreaUnit::SquareMiles:
1383 return NM2_TO_M2 / MI2_TO_M2;
1384 case Qgis::AreaUnit::Hectares:
1385 return NM2_TO_M2 / HA_TO_M2;
1386 case Qgis::AreaUnit::Acres:
1387 return NM2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
1388 case Qgis::AreaUnit::SquareNauticalMiles:
1389 return 1.0;
1390 case Qgis::AreaUnit::SquareDegrees:
1391 return NM2_TO_M2 / DEG2_TO_M2;
1392 case Qgis::AreaUnit::SquareCentimeters:
1393 return NM2_TO_M2 / CM2_TO_M2;
1394 case Qgis::AreaUnit::SquareMillimeters:
1395 return NM2_TO_M2 / MM2_TO_M2;
1396 case Qgis::AreaUnit::SquareInches:
1397 return NM2_TO_M2 / IN2_TO_M2;
1398 case Qgis::AreaUnit::Unknown:
1399 break;
1400 }
1401
1402 break;
1403 }
1404
1405 case Qgis::AreaUnit::SquareDegrees:
1406 {
1407 switch ( toUnit )
1408 {
1409 case Qgis::AreaUnit::SquareMeters:
1410 return DEG2_TO_M2;
1411 case Qgis::AreaUnit::SquareKilometers:
1412 return DEG2_TO_M2 / KM2_TO_M2;
1413 case Qgis::AreaUnit::SquareFeet:
1414 return DEG2_TO_M2 / FT2_TO_M2;
1415 case Qgis::AreaUnit::SquareYards:
1416 return DEG2_TO_M2 / YD2_TO_M2;
1417 case Qgis::AreaUnit::SquareMiles:
1418 return DEG2_TO_M2 / MI2_TO_M2;
1419 case Qgis::AreaUnit::Hectares:
1420 return DEG2_TO_M2 / HA_TO_M2;
1421 case Qgis::AreaUnit::Acres:
1422 return DEG2_TO_M2 / FT2_TO_M2 / AC_TO_FT2;
1423 case Qgis::AreaUnit::SquareNauticalMiles:
1424 return DEG2_TO_M2 / NM2_TO_M2;
1425 case Qgis::AreaUnit::SquareDegrees:
1426 return 1.0;
1427 case Qgis::AreaUnit::SquareCentimeters:
1428 return DEG2_TO_M2 / CM2_TO_M2;
1429 case Qgis::AreaUnit::SquareMillimeters:
1430 return DEG2_TO_M2 / MM2_TO_M2;
1431 case Qgis::AreaUnit::SquareInches:
1432 return DEG2_TO_M2 / IN2_TO_M2;
1433 case Qgis::AreaUnit::Unknown:
1434 break;
1435 }
1436
1437 break;
1438 }
1439
1440 case Qgis::AreaUnit::SquareMillimeters:
1441 {
1442 switch ( toUnit )
1443 {
1444 case Qgis::AreaUnit::SquareMeters:
1445 return MM2_TO_M2;
1446 case Qgis::AreaUnit::SquareKilometers:
1447 return MM2_TO_M2 / KM2_TO_M2;
1448 case Qgis::AreaUnit::SquareFeet:
1449 return MM2_TO_M2 / FT2_TO_M2;
1450 case Qgis::AreaUnit::SquareYards:
1451 return MM2_TO_M2 / YD2_TO_M2;
1452 case Qgis::AreaUnit::SquareMiles:
1453 return MM2_TO_M2 / MI2_TO_M2;
1454 case Qgis::AreaUnit::Hectares:
1455 return MM2_TO_M2 / HA_TO_M2;
1456 case Qgis::AreaUnit::Acres:
1457 return MM2_TO_M2 / AC_TO_FT2 / FT2_TO_M2;
1458 case Qgis::AreaUnit::SquareNauticalMiles:
1459 return MM2_TO_M2 / NM2_TO_M2;
1460 case Qgis::AreaUnit::SquareDegrees:
1461 return MM2_TO_M2 / DEG2_TO_M2;
1462 case Qgis::AreaUnit::SquareCentimeters:
1463 return MM2_TO_M2 / CM2_TO_M2;
1464 case Qgis::AreaUnit::SquareMillimeters:
1465 return 1.0;
1466 case Qgis::AreaUnit::SquareInches:
1467 return MM2_TO_M2 / IN2_TO_M2;
1468 case Qgis::AreaUnit::Unknown:
1469 break;
1470 }
1471
1472 break;
1473 }
1474 case Qgis::AreaUnit::SquareCentimeters:
1475 {
1476 switch ( toUnit )
1477 {
1478 case Qgis::AreaUnit::SquareMeters:
1479 return CM2_TO_M2;
1480 case Qgis::AreaUnit::SquareKilometers:
1481 return CM2_TO_M2 / KM2_TO_M2;
1482 case Qgis::AreaUnit::SquareFeet:
1483 return CM2_TO_M2 / FT2_TO_M2;
1484 case Qgis::AreaUnit::SquareYards:
1485 return CM2_TO_M2 / YD2_TO_M2;
1486 case Qgis::AreaUnit::SquareMiles:
1487 return CM2_TO_M2 / MI2_TO_M2;
1488 case Qgis::AreaUnit::Hectares:
1489 return CM2_TO_M2 / HA_TO_M2;
1490 case Qgis::AreaUnit::Acres:
1491 return CM2_TO_M2 / AC_TO_FT2 / FT2_TO_M2;
1492 case Qgis::AreaUnit::SquareNauticalMiles:
1493 return CM2_TO_M2 / NM2_TO_M2;
1494 case Qgis::AreaUnit::SquareDegrees:
1495 return CM2_TO_M2 / DEG2_TO_M2;
1496 case Qgis::AreaUnit::SquareCentimeters:
1497 return 1.0;
1498 case Qgis::AreaUnit::SquareMillimeters:
1499 return CM2_TO_M2 / MM2_TO_M2;
1500 case Qgis::AreaUnit::SquareInches:
1501 return CM2_TO_M2 / IN2_TO_M2;
1502 case Qgis::AreaUnit::Unknown:
1503 break;
1504 }
1505
1506 break;
1507 }
1508 case Qgis::AreaUnit::SquareInches:
1509 {
1510 switch ( toUnit )
1511 {
1512 case Qgis::AreaUnit::SquareMeters:
1513 return IN2_TO_M2;
1514 case Qgis::AreaUnit::SquareKilometers:
1515 return IN2_TO_M2 / KM2_TO_M2;
1516 case Qgis::AreaUnit::SquareFeet:
1517 return IN2_TO_M2 / FT2_TO_M2;
1518 case Qgis::AreaUnit::SquareYards:
1519 return IN2_TO_M2 / YD2_TO_M2;
1520 case Qgis::AreaUnit::SquareMiles:
1521 return IN2_TO_M2 / MI2_TO_M2;
1522 case Qgis::AreaUnit::Hectares:
1523 return IN2_TO_M2 / HA_TO_M2;
1524 case Qgis::AreaUnit::Acres:
1525 return IN2_TO_M2 / AC_TO_FT2 / FT2_TO_M2;
1526 case Qgis::AreaUnit::SquareNauticalMiles:
1527 return IN2_TO_M2 / NM2_TO_M2;
1528 case Qgis::AreaUnit::SquareDegrees:
1529 return IN2_TO_M2 / DEG2_TO_M2;
1530 case Qgis::AreaUnit::SquareCentimeters:
1531 return IN2_TO_M2 / CM2_TO_M2;
1532 case Qgis::AreaUnit::SquareMillimeters:
1533 return IN2_TO_M2 / MM2_TO_M2;
1534 case Qgis::AreaUnit::SquareInches:
1535 return 1;
1536 case Qgis::AreaUnit::Unknown:
1537 break;
1538 }
1539
1540 break;
1541 }
1542 case Qgis::AreaUnit::Unknown:
1543 break;
1544 }
1545 return 1.0;
1546}
1547
1548Qgis::AreaUnit QgsUnitTypes::distanceToAreaUnit( Qgis::DistanceUnit distanceUnit )
1549{
1550 switch ( distanceUnit )
1551 {
1552 case Qgis::DistanceUnit::Meters:
1553 case Qgis::DistanceUnit::MetersGermanLegal:
1554 return Qgis::AreaUnit::SquareMeters;
1555
1556 case Qgis::DistanceUnit::Kilometers:
1557 return Qgis::AreaUnit::SquareKilometers;
1558
1559 case Qgis::DistanceUnit::Centimeters:
1560 return Qgis::AreaUnit::SquareCentimeters;
1561
1562 case Qgis::DistanceUnit::Millimeters:
1563 return Qgis::AreaUnit::SquareMillimeters;
1564
1565 case Qgis::DistanceUnit::Feet:
1566 case Qgis::DistanceUnit::ChainsInternational:
1567 case Qgis::DistanceUnit::ChainsBritishBenoit1895A:
1568 case Qgis::DistanceUnit::ChainsBritishBenoit1895B:
1569 case Qgis::DistanceUnit::ChainsBritishSears1922Truncated:
1570 case Qgis::DistanceUnit::ChainsBritishSears1922:
1571 case Qgis::DistanceUnit::ChainsClarkes:
1572 case Qgis::DistanceUnit::ChainsUSSurvey:
1573 case Qgis::DistanceUnit::FeetBritish1865:
1574 case Qgis::DistanceUnit::FeetBritish1936:
1575 case Qgis::DistanceUnit::FeetBritishBenoit1895A:
1576 case Qgis::DistanceUnit::FeetBritishBenoit1895B:
1577 case Qgis::DistanceUnit::FeetBritishSears1922Truncated:
1578 case Qgis::DistanceUnit::FeetBritishSears1922:
1579 case Qgis::DistanceUnit::FeetClarkes:
1580 case Qgis::DistanceUnit::FeetGoldCoast:
1581 case Qgis::DistanceUnit::FeetIndian:
1582 case Qgis::DistanceUnit::FeetIndian1937:
1583 case Qgis::DistanceUnit::FeetIndian1962:
1584 case Qgis::DistanceUnit::FeetIndian1975:
1585 case Qgis::DistanceUnit::FeetUSSurvey:
1586 case Qgis::DistanceUnit::LinksInternational:
1587 case Qgis::DistanceUnit::LinksBritishBenoit1895A:
1588 case Qgis::DistanceUnit::LinksBritishBenoit1895B:
1589 case Qgis::DistanceUnit::LinksBritishSears1922Truncated:
1590 case Qgis::DistanceUnit::LinksBritishSears1922:
1591 case Qgis::DistanceUnit::LinksClarkes:
1592 case Qgis::DistanceUnit::LinksUSSurvey:
1593 case Qgis::DistanceUnit::YardsBritishBenoit1895A:
1594 case Qgis::DistanceUnit::YardsBritishBenoit1895B:
1595 case Qgis::DistanceUnit::YardsBritishSears1922Truncated:
1596 case Qgis::DistanceUnit::YardsBritishSears1922:
1597 case Qgis::DistanceUnit::YardsClarkes:
1598 case Qgis::DistanceUnit::YardsIndian:
1599 case Qgis::DistanceUnit::YardsIndian1937:
1600 case Qgis::DistanceUnit::YardsIndian1962:
1601 case Qgis::DistanceUnit::YardsIndian1975:
1602 case Qgis::DistanceUnit::Fathoms:
1603 return Qgis::AreaUnit::SquareFeet;
1604
1605 case Qgis::DistanceUnit::Yards:
1606 return Qgis::AreaUnit::SquareYards;
1607
1608 case Qgis::DistanceUnit::Miles:
1609 case Qgis::DistanceUnit::MilesUSSurvey:
1610 return Qgis::AreaUnit::SquareMiles;
1611
1612 case Qgis::DistanceUnit::Degrees:
1613 return Qgis::AreaUnit::SquareDegrees;
1614
1615 case Qgis::DistanceUnit::Unknown:
1616 return Qgis::AreaUnit::Unknown;
1617
1618 case Qgis::DistanceUnit::NauticalMiles:
1619 return Qgis::AreaUnit::SquareNauticalMiles;
1620
1621 case Qgis::DistanceUnit::Inches:
1622 return Qgis::AreaUnit::SquareInches;
1623 }
1624
1625 return Qgis::AreaUnit::Unknown;
1626}
1627
1670
1671QString QgsUnitTypes::encodeUnit( Qgis::TemporalUnit unit )
1672{
1673 switch ( unit )
1674 {
1675 case Qgis::TemporalUnit::Seconds:
1676 return QStringLiteral( "s" );
1677 case Qgis::TemporalUnit::Milliseconds:
1678 return QStringLiteral( "ms" );
1679 case Qgis::TemporalUnit::Minutes:
1680 return QStringLiteral( "min" );
1681 case Qgis::TemporalUnit::Hours:
1682 return QStringLiteral( "h" );
1683 case Qgis::TemporalUnit::Days:
1684 return QStringLiteral( "d" );
1685 case Qgis::TemporalUnit::Weeks:
1686 return QStringLiteral( "wk" );
1687 case Qgis::TemporalUnit::Months:
1688 return QStringLiteral( "mon" );
1689 case Qgis::TemporalUnit::Years:
1690 return QStringLiteral( "y" );
1691 case Qgis::TemporalUnit::Decades:
1692 return QStringLiteral( "dec" );
1693 case Qgis::TemporalUnit::Centuries:
1694 return QStringLiteral( "c" );
1695 case Qgis::TemporalUnit::IrregularStep:
1696 return QStringLiteral( "xxx" );
1697 case Qgis::TemporalUnit::Unknown:
1698 return QStringLiteral( "<unknown>" );
1699 }
1700 return QString();
1701}
1702
1703Qgis::TemporalUnit QgsUnitTypes::decodeTemporalUnit( const QString &string, bool *ok )
1704{
1705 const QString normalized = string.trimmed().toLower();
1706
1707 if ( ok )
1708 *ok = true;
1709
1710 if ( normalized == encodeUnit( Qgis::TemporalUnit::Seconds ) )
1711 return Qgis::TemporalUnit::Seconds;
1712 if ( normalized == encodeUnit( Qgis::TemporalUnit::Milliseconds ) )
1713 return Qgis::TemporalUnit::Milliseconds;
1714 if ( normalized == encodeUnit( Qgis::TemporalUnit::Minutes ) )
1715 return Qgis::TemporalUnit::Minutes;
1716 if ( normalized == encodeUnit( Qgis::TemporalUnit::Hours ) )
1717 return Qgis::TemporalUnit::Hours;
1718 if ( normalized == encodeUnit( Qgis::TemporalUnit::Days ) )
1719 return Qgis::TemporalUnit::Days;
1720 if ( normalized == encodeUnit( Qgis::TemporalUnit::Weeks ) )
1721 return Qgis::TemporalUnit::Weeks;
1722 if ( normalized == encodeUnit( Qgis::TemporalUnit::Months ) )
1723 return Qgis::TemporalUnit::Months;
1724 if ( normalized == encodeUnit( Qgis::TemporalUnit::Years ) )
1725 return Qgis::TemporalUnit::Years;
1726 if ( normalized == encodeUnit( Qgis::TemporalUnit::Decades ) )
1727 return Qgis::TemporalUnit::Decades;
1728 if ( normalized == encodeUnit( Qgis::TemporalUnit::Centuries ) )
1729 return Qgis::TemporalUnit::Centuries;
1730 if ( normalized == encodeUnit( Qgis::TemporalUnit::IrregularStep ) )
1731 return Qgis::TemporalUnit::IrregularStep;
1732 if ( normalized == encodeUnit( Qgis::TemporalUnit::Unknown ) )
1733 return Qgis::TemporalUnit::Unknown;
1734
1735 if ( ok )
1736 *ok = false;
1737
1738 return Qgis::TemporalUnit::Unknown;
1739}
1740
1741QString QgsUnitTypes::toString( Qgis::TemporalUnit unit )
1742{
1743 switch ( unit )
1744 {
1745 case Qgis::TemporalUnit::Seconds:
1746 return QObject::tr( "seconds", "temporal" );
1747 case Qgis::TemporalUnit::Milliseconds:
1748 return QObject::tr( "milliseconds", "temporal" );
1749 case Qgis::TemporalUnit::Minutes:
1750 return QObject::tr( "minutes", "temporal" );
1751 case Qgis::TemporalUnit::Hours:
1752 return QObject::tr( "hours", "temporal" );
1753 case Qgis::TemporalUnit::Days:
1754 return QObject::tr( "days", "temporal" );
1755 case Qgis::TemporalUnit::Weeks:
1756 return QObject::tr( "weeks", "temporal" );
1757 case Qgis::TemporalUnit::Months:
1758 return QObject::tr( "months", "temporal" );
1759 case Qgis::TemporalUnit::Years:
1760 return QObject::tr( "years", "temporal" );
1761 case Qgis::TemporalUnit::Decades:
1762 return QObject::tr( "decades", "temporal" );
1763 case Qgis::TemporalUnit::Centuries:
1764 return QObject::tr( "centuries", "temporal" );
1765 case Qgis::TemporalUnit::IrregularStep:
1766 return QObject::tr( "steps", "temporal" );
1767 case Qgis::TemporalUnit::Unknown:
1768 return QObject::tr( "<unknown>", "temporal" );
1769 }
1770 return QString();
1771}
1772
1773QString QgsUnitTypes::toAbbreviatedString( Qgis::TemporalUnit unit )
1774{
1775 switch ( unit )
1776 {
1777 case Qgis::TemporalUnit::Seconds:
1778 return QObject::tr( "s", "temporal" );
1779 case Qgis::TemporalUnit::Milliseconds:
1780 return QObject::tr( "ms", "temporal" );
1781 case Qgis::TemporalUnit::Minutes:
1782 return QObject::tr( "min", "temporal" );
1783 case Qgis::TemporalUnit::Hours:
1784 return QObject::tr( "h", "temporal" );
1785 case Qgis::TemporalUnit::Days:
1786 return QObject::tr( "d", "temporal" );
1787 case Qgis::TemporalUnit::Weeks:
1788 return QObject::tr( "wk", "temporal" );
1789 case Qgis::TemporalUnit::Months:
1790 return QObject::tr( "mon", "temporal" );
1791 case Qgis::TemporalUnit::Years:
1792 return QObject::tr( "y", "temporal" );
1793 case Qgis::TemporalUnit::Decades:
1794 return QObject::tr( "dec", "temporal" );
1795 case Qgis::TemporalUnit::Centuries:
1796 return QObject::tr( "cen", "temporal" );
1797 case Qgis::TemporalUnit::IrregularStep:
1798 return QObject::tr( "steps", "temporal" );
1799 case Qgis::TemporalUnit::Unknown:
1800 return QObject::tr( "<unknown>", "temporal" );
1801 }
1802 return QString();
1803}
1804
1805Qgis::TemporalUnit QgsUnitTypes::stringToTemporalUnit( const QString &string, bool *ok )
1806{
1807 const QString normalized = string.trimmed().toLower();
1808
1809 if ( ok )
1810 *ok = true;
1811
1812 if ( normalized == toString( Qgis::TemporalUnit::Seconds ) )
1813 return Qgis::TemporalUnit::Seconds;
1814 if ( normalized == toString( Qgis::TemporalUnit::Milliseconds ) )
1815 return Qgis::TemporalUnit::Milliseconds;
1816 if ( normalized == toString( Qgis::TemporalUnit::Minutes ) )
1817 return Qgis::TemporalUnit::Minutes;
1818 if ( normalized == toString( Qgis::TemporalUnit::Hours ) )
1819 return Qgis::TemporalUnit::Hours;
1820 if ( normalized == toString( Qgis::TemporalUnit::Days ) )
1821 return Qgis::TemporalUnit::Days;
1822 if ( normalized == toString( Qgis::TemporalUnit::Weeks ) )
1823 return Qgis::TemporalUnit::Weeks;
1824 if ( normalized == toString( Qgis::TemporalUnit::Months ) )
1825 return Qgis::TemporalUnit::Months;
1826 if ( normalized == toString( Qgis::TemporalUnit::Years ) )
1827 return Qgis::TemporalUnit::Years;
1828 if ( normalized == toString( Qgis::TemporalUnit::Decades ) )
1829 return Qgis::TemporalUnit::Decades;
1830 if ( normalized == toString( Qgis::TemporalUnit::Centuries ) )
1831 return Qgis::TemporalUnit::Centuries;
1832 if ( normalized == toString( Qgis::TemporalUnit::IrregularStep ) )
1833 return Qgis::TemporalUnit::IrregularStep;
1834 if ( normalized == toString( Qgis::TemporalUnit::Unknown ) )
1835 return Qgis::TemporalUnit::Unknown;
1836
1837 if ( ok )
1838 *ok = false;
1839
1840 return Qgis::TemporalUnit::Unknown;
1841}
1842
1843double QgsUnitTypes::fromUnitToUnitFactor( Qgis::TemporalUnit fromUnit, Qgis::TemporalUnit toUnit )
1844{
1845 switch ( fromUnit )
1846 {
1847 case Qgis::TemporalUnit::Seconds:
1848 {
1849 switch ( toUnit )
1850 {
1851 case Qgis::TemporalUnit::Seconds:
1852 return 1.0;
1853 case Qgis::TemporalUnit::Milliseconds:
1854 return 1000.0;
1855 case Qgis::TemporalUnit::Minutes:
1856 return 1 / 60.0;
1857 case Qgis::TemporalUnit::Hours:
1858 return 1 / 3600.0;
1859 case Qgis::TemporalUnit::Days:
1860 return 1 / 86400.0;
1861 case Qgis::TemporalUnit::Weeks:
1862 return 1 / 604800.0;
1863 case Qgis::TemporalUnit::Months:
1864 return 1 / 2592000.0;
1865 case Qgis::TemporalUnit::Years:
1866 return 1 / 31557600.0;
1867 case Qgis::TemporalUnit::Decades:
1868 return 1 / 315576000.0;
1869 case Qgis::TemporalUnit::Centuries:
1870 return 1 / 3155760000.0;
1871 case Qgis::TemporalUnit::Unknown:
1872 case Qgis::TemporalUnit::IrregularStep:
1873 return 1.0;
1874 }
1875 break;
1876 }
1877 case Qgis::TemporalUnit::Milliseconds:
1878 {
1879 switch ( toUnit )
1880 {
1881 case Qgis::TemporalUnit::Seconds:
1882 return 1 / 1000.0;
1883 case Qgis::TemporalUnit::Milliseconds:
1884 return 1.0;
1885 case Qgis::TemporalUnit::Minutes:
1886 return 1 / 60000.0;
1887 case Qgis::TemporalUnit::Hours:
1888 return 1 / 3600000.0;
1889 case Qgis::TemporalUnit::Days:
1890 return 1 / 86400000.0;
1891 case Qgis::TemporalUnit::Weeks:
1892 return 1 / 604800000.0;
1893 case Qgis::TemporalUnit::Months:
1894 return 1 / 2592000000.0;
1895 case Qgis::TemporalUnit::Years:
1896 return 1 / 31557600000.0;
1897 case Qgis::TemporalUnit::Decades:
1898 return 1 / 315576000000.0;
1899 case Qgis::TemporalUnit::Centuries:
1900 return 1 / 3155760000000.0;
1901 case Qgis::TemporalUnit::Unknown:
1902 case Qgis::TemporalUnit::IrregularStep:
1903 return 1.0;
1904 }
1905 break;
1906 }
1907 case Qgis::TemporalUnit::Minutes:
1908 {
1909 switch ( toUnit )
1910 {
1911 case Qgis::TemporalUnit::Seconds:
1912 return 60.0;
1913 case Qgis::TemporalUnit::Milliseconds:
1914 return 60000.0;
1915 case Qgis::TemporalUnit::Minutes:
1916 return 1;
1917 case Qgis::TemporalUnit::Hours:
1918 return 1 / 60.0;
1919 case Qgis::TemporalUnit::Days:
1920 return 1 / 1440.0;
1921 case Qgis::TemporalUnit::Weeks:
1922 return 1 / 10080.0;
1923 case Qgis::TemporalUnit::Months:
1924 return 1 / 43200.0;
1925 case Qgis::TemporalUnit::Years:
1926 return 1 / 525960.0;
1927 case Qgis::TemporalUnit::Decades:
1928 return 1 / 5259600.0;
1929 case Qgis::TemporalUnit::Centuries:
1930 return 1 / 52596000.0;
1931 case Qgis::TemporalUnit::Unknown:
1932 case Qgis::TemporalUnit::IrregularStep:
1933 return 1.0;
1934 }
1935 break;
1936 }
1937 case Qgis::TemporalUnit::Hours:
1938 {
1939 switch ( toUnit )
1940 {
1941 case Qgis::TemporalUnit::Seconds:
1942 return 3600.0;
1943 case Qgis::TemporalUnit::Milliseconds:
1944 return 3600000.0;
1945 case Qgis::TemporalUnit::Minutes:
1946 return 60;
1947 case Qgis::TemporalUnit::Hours:
1948 return 1;
1949 case Qgis::TemporalUnit::Days:
1950 return 1 / 24.0;
1951 case Qgis::TemporalUnit::Weeks:
1952 return 1 / 168.0;
1953 case Qgis::TemporalUnit::Months:
1954 return 1 / 720.0;
1955 case Qgis::TemporalUnit::Years:
1956 return 1 / 8766.0;
1957 case Qgis::TemporalUnit::Decades:
1958 return 1 / 87660.0;
1959 case Qgis::TemporalUnit::Centuries:
1960 return 1 / 876600.0;
1961 case Qgis::TemporalUnit::Unknown:
1962 case Qgis::TemporalUnit::IrregularStep:
1963 return 1.0;
1964 }
1965 break;
1966 }
1967 case Qgis::TemporalUnit::Days:
1968 {
1969 switch ( toUnit )
1970 {
1971 case Qgis::TemporalUnit::Seconds:
1972 return 86400.0;
1973 case Qgis::TemporalUnit::Milliseconds:
1974 return 86400000.0;
1975 case Qgis::TemporalUnit::Minutes:
1976 return 1440;
1977 case Qgis::TemporalUnit::Hours:
1978 return 24;
1979 case Qgis::TemporalUnit::Days:
1980 return 1;
1981 case Qgis::TemporalUnit::Weeks:
1982 return 1 / 7.0;
1983 case Qgis::TemporalUnit::Months:
1984 return 1 / 30.0;
1985 case Qgis::TemporalUnit::Years:
1986 return 1 / 365.25;
1987 case Qgis::TemporalUnit::Decades:
1988 return 1 / 3652.5;
1989 case Qgis::TemporalUnit::Centuries:
1990 return 1 / 36525.0;
1991 case Qgis::TemporalUnit::Unknown:
1992 case Qgis::TemporalUnit::IrregularStep:
1993 return 1.0;
1994 }
1995 break;
1996 }
1997 case Qgis::TemporalUnit::Weeks:
1998 {
1999 switch ( toUnit )
2000 {
2001 case Qgis::TemporalUnit::Seconds:
2002 return 604800.0;
2003 case Qgis::TemporalUnit::Milliseconds:
2004 return 604800000.0;
2005 case Qgis::TemporalUnit::Minutes:
2006 return 10080;
2007 case Qgis::TemporalUnit::Hours:
2008 return 168;
2009 case Qgis::TemporalUnit::Days:
2010 return 7;
2011 case Qgis::TemporalUnit::Weeks:
2012 return 1;
2013 case Qgis::TemporalUnit::Months:
2014 return 7 / 30.0;
2015 case Qgis::TemporalUnit::Years:
2016 return 7 / 365.25;
2017 case Qgis::TemporalUnit::Decades:
2018 return 7 / 3652.5;
2019 case Qgis::TemporalUnit::Centuries:
2020 return 7 / 36525.0;
2021 case Qgis::TemporalUnit::Unknown:
2022 case Qgis::TemporalUnit::IrregularStep:
2023 return 1.0;
2024 }
2025 break;
2026 }
2027 case Qgis::TemporalUnit::Months:
2028 {
2029 switch ( toUnit )
2030 {
2031 case Qgis::TemporalUnit::Seconds:
2032 return 2592000.0;
2033 case Qgis::TemporalUnit::Milliseconds:
2034 return 2592000000.0;
2035 case Qgis::TemporalUnit::Minutes:
2036 return 43200;
2037 case Qgis::TemporalUnit::Hours:
2038 return 720;
2039 case Qgis::TemporalUnit::Days:
2040 return 30;
2041 case Qgis::TemporalUnit::Weeks:
2042 return 30 / 7.0;
2043 case Qgis::TemporalUnit::Months:
2044 return 1;
2045 case Qgis::TemporalUnit::Years:
2046 return 30 / 365.25;
2047 case Qgis::TemporalUnit::Decades:
2048 return 30 / 3652.5;
2049 case Qgis::TemporalUnit::Centuries:
2050 return 30 / 36525.0;
2051 case Qgis::TemporalUnit::Unknown:
2052 case Qgis::TemporalUnit::IrregularStep:
2053 return 1.0;
2054 }
2055 break;
2056 }
2057 case Qgis::TemporalUnit::Years:
2058 {
2059 switch ( toUnit )
2060 {
2061 case Qgis::TemporalUnit::Seconds:
2062 return 31557600.0;
2063 case Qgis::TemporalUnit::Milliseconds:
2064 return 31557600000.0;
2065 case Qgis::TemporalUnit::Minutes:
2066 return 525960.0;
2067 case Qgis::TemporalUnit::Hours:
2068 return 8766.0;
2069 case Qgis::TemporalUnit::Days:
2070 return 365.25;
2071 case Qgis::TemporalUnit::Weeks:
2072 return 365.25 / 7.0;
2073 case Qgis::TemporalUnit::Months:
2074 return 365.25 / 30.0;
2075 case Qgis::TemporalUnit::Years:
2076 return 1;
2077 case Qgis::TemporalUnit::Decades:
2078 return 0.1;
2079 case Qgis::TemporalUnit::Centuries:
2080 return 0.01;
2081 case Qgis::TemporalUnit::Unknown:
2082 case Qgis::TemporalUnit::IrregularStep:
2083 return 1.0;
2084 }
2085 break;
2086 }
2087 case Qgis::TemporalUnit::Decades:
2088 {
2089 switch ( toUnit )
2090 {
2091 case Qgis::TemporalUnit::Seconds:
2092 return 315576000.0;
2093 case Qgis::TemporalUnit::Milliseconds:
2094 return 315576000000.0;
2095 case Qgis::TemporalUnit::Minutes:
2096 return 5259600.0;
2097 case Qgis::TemporalUnit::Hours:
2098 return 87660.0;
2099 case Qgis::TemporalUnit::Days:
2100 return 3652.5;
2101 case Qgis::TemporalUnit::Weeks:
2102 return 3652.5 / 7.0;
2103 case Qgis::TemporalUnit::Months:
2104 return 3652.5 / 30.0;
2105 case Qgis::TemporalUnit::Years:
2106 return 10;
2107 case Qgis::TemporalUnit::Decades:
2108 return 1;
2109 case Qgis::TemporalUnit::Centuries:
2110 return 0.1;
2111 case Qgis::TemporalUnit::Unknown:
2112 case Qgis::TemporalUnit::IrregularStep:
2113 return 1.0;
2114 }
2115 break;
2116 }
2117
2118 case Qgis::TemporalUnit::Centuries:
2119 {
2120 switch ( toUnit )
2121 {
2122 case Qgis::TemporalUnit::Seconds:
2123 return 3155760000.0;
2124 case Qgis::TemporalUnit::Milliseconds:
2125 return 3155760000000.0;
2126 case Qgis::TemporalUnit::Minutes:
2127 return 52596000.0;
2128 case Qgis::TemporalUnit::Hours:
2129 return 876600.0;
2130 case Qgis::TemporalUnit::Days:
2131 return 36525;
2132 case Qgis::TemporalUnit::Weeks:
2133 return 36525 / 7.0;
2134 case Qgis::TemporalUnit::Months:
2135 return 36525 / 30.0;
2136 case Qgis::TemporalUnit::Years:
2137 return 100;
2138 case Qgis::TemporalUnit::Decades:
2139 return 10;
2140 case Qgis::TemporalUnit::Centuries:
2141 return 1;
2142 case Qgis::TemporalUnit::Unknown:
2143 case Qgis::TemporalUnit::IrregularStep:
2144 return 1.0;
2145 }
2146 break;
2147 }
2148
2149 case Qgis::TemporalUnit::Unknown:
2150 case Qgis::TemporalUnit::IrregularStep:
2151 {
2152 return 1.0;
2153 }
2154 }
2155 return 1.0;
2156}
2157
2158Qgis::VolumeUnit QgsUnitTypes::decodeVolumeUnit( const QString &string, bool *ok )
2159{
2160 const QString normalized = string.trimmed().toLower();
2161
2162 if ( ok )
2163 *ok = true;
2164
2165 if ( normalized == encodeUnit( Qgis::VolumeUnit::CubicMeters ) )
2166 return Qgis::VolumeUnit::CubicMeters;
2167 if ( normalized == encodeUnit( Qgis::VolumeUnit::CubicFeet ) )
2168 return Qgis::VolumeUnit::CubicFeet;
2169 if ( normalized == encodeUnit( Qgis::VolumeUnit::CubicYards ) )
2170 return Qgis::VolumeUnit::CubicYards;
2171 if ( normalized == encodeUnit( Qgis::VolumeUnit::Barrel ) )
2172 return Qgis::VolumeUnit::Barrel;
2173 if ( normalized == encodeUnit( Qgis::VolumeUnit::CubicDecimeter ) )
2174 return Qgis::VolumeUnit::CubicDecimeter;
2175 if ( normalized == encodeUnit( Qgis::VolumeUnit::Liters ) )
2176 return Qgis::VolumeUnit::Liters;
2177 if ( normalized == encodeUnit( Qgis::VolumeUnit::GallonUS ) )
2178 return Qgis::VolumeUnit::GallonUS;
2179 if ( normalized == encodeUnit( Qgis::VolumeUnit::CubicInch ) )
2180 return Qgis::VolumeUnit::CubicInch;
2181 if ( normalized == encodeUnit( Qgis::VolumeUnit::CubicCentimeter ) )
2182 return Qgis::VolumeUnit::CubicCentimeter;
2183 if ( normalized == encodeUnit( Qgis::VolumeUnit::CubicDegrees ) )
2184 return Qgis::VolumeUnit::CubicDegrees;
2185 if ( normalized == encodeUnit( Qgis::VolumeUnit::Unknown ) )
2186 return Qgis::VolumeUnit::Unknown;
2187
2188 if ( ok )
2189 *ok = false;
2190
2191 return Qgis::VolumeUnit::Unknown;
2192}
2193
2194QString QgsUnitTypes::toString( Qgis::VolumeUnit unit )
2195{
2196 switch ( unit )
2197 {
2198 case Qgis::VolumeUnit::CubicMeters:
2199 return QObject::tr( "cubic meters", "volume" );
2200 case Qgis::VolumeUnit::CubicFeet:
2201 return QObject::tr( "cubic feet", "volume" );
2202 case Qgis::VolumeUnit::CubicYards:
2203 return QObject::tr( "cubic yards", "volume" );
2204 case Qgis::VolumeUnit::Barrel:
2205 return QObject::tr( "barrels", "volume" );
2206 case Qgis::VolumeUnit::CubicDecimeter:
2207 return QObject::tr( "cubic decimeters", "volume" );
2208 case Qgis::VolumeUnit::Liters:
2209 return QObject::tr( "liters", "volume" );
2210 case Qgis::VolumeUnit::GallonUS:
2211 return QObject::tr( "gallons", "volume" );
2212 case Qgis::VolumeUnit::CubicInch:
2213 return QObject::tr( "cubic inches", "volume" );
2214 case Qgis::VolumeUnit::CubicCentimeter:
2215 return QObject::tr( "cubic centimeters", "volume" );
2216 case Qgis::VolumeUnit::CubicDegrees:
2217 return QObject::tr( "cubic degrees", "volume" );
2218 case Qgis::VolumeUnit::Unknown:
2219 return QObject::tr( "<unknown>", "volume" );
2220 }
2221 return QString();
2222}
2223
2224QString QgsUnitTypes::toAbbreviatedString( Qgis::VolumeUnit unit )
2225{
2226 switch ( unit )
2227 {
2228 case Qgis::VolumeUnit::CubicMeters:
2229 return QObject::tr( "m³", "volume" );
2230 case Qgis::VolumeUnit::CubicFeet:
2231 return QObject::tr( "ft³", "volume" );
2232 case Qgis::VolumeUnit::CubicYards:
2233 return QObject::tr( "yds³", "volume" );
2234 case Qgis::VolumeUnit::Barrel:
2235 return QObject::tr( "bbl", "volume" );
2236 case Qgis::VolumeUnit::CubicDecimeter:
2237 return QObject::tr( "dm³", "volume" );
2238 case Qgis::VolumeUnit::Liters:
2239 return QObject::tr( "l", "volume" );
2240 case Qgis::VolumeUnit::GallonUS:
2241 return QObject::tr( "gal", "volume" );
2242 case Qgis::VolumeUnit::CubicInch:
2243 return QObject::tr( "in³", "volume" );
2244 case Qgis::VolumeUnit::CubicCentimeter:
2245 return QObject::tr( "cm³", "volume" );
2246 case Qgis::VolumeUnit::CubicDegrees:
2247 return QObject::tr( "deg³", "volume" );
2248 case Qgis::VolumeUnit::Unknown:
2249 return QObject::tr( "<unknown>", "volume" );
2250 }
2251 return QString();
2252
2253}
2254
2255Qgis::VolumeUnit QgsUnitTypes::stringToVolumeUnit( const QString &string, bool *ok )
2256{
2257 const QString normalized = string.trimmed().toLower();
2258
2259 if ( ok )
2260 *ok = true;
2261
2262 if ( normalized == toString( Qgis::VolumeUnit::CubicMeters ) )
2263 return Qgis::VolumeUnit::CubicMeters;
2264 if ( normalized == toString( Qgis::VolumeUnit::CubicFeet ) )
2265 return Qgis::VolumeUnit::CubicFeet;
2266 if ( normalized == toString( Qgis::VolumeUnit::CubicYards ) )
2267 return Qgis::VolumeUnit::CubicYards;
2268 if ( normalized == toString( Qgis::VolumeUnit::Barrel ) )
2269 return Qgis::VolumeUnit::Barrel;
2270 if ( normalized == toString( Qgis::VolumeUnit::CubicDecimeter ) )
2271 return Qgis::VolumeUnit::CubicDecimeter;
2272 if ( normalized == toString( Qgis::VolumeUnit::Liters ) )
2273 return Qgis::VolumeUnit::Liters;
2274 if ( normalized == toString( Qgis::VolumeUnit::GallonUS ) )
2275 return Qgis::VolumeUnit::GallonUS;
2276 if ( normalized == toString( Qgis::VolumeUnit::CubicInch ) )
2277 return Qgis::VolumeUnit::CubicInch;
2278 if ( normalized == toString( Qgis::VolumeUnit::CubicCentimeter ) )
2279 return Qgis::VolumeUnit::CubicCentimeter;
2280 if ( normalized == toString( Qgis::VolumeUnit::CubicDegrees ) )
2281 return Qgis::VolumeUnit::CubicDegrees;
2282 if ( normalized == toString( Qgis::VolumeUnit::Unknown ) )
2283 return Qgis::VolumeUnit::Unknown;
2284
2285 if ( ok )
2286 *ok = false;
2287
2288 return Qgis::VolumeUnit::Unknown;
2289}
2290
2291#define DEG2_TO_M3 1379474361572186.2
2292double QgsUnitTypes::fromUnitToUnitFactor( Qgis::VolumeUnit fromUnit, Qgis::VolumeUnit toUnit )
2293{
2294 // cloned branches are intentional here for improved readability
2295 // NOLINTBEGIN(bugprone-branch-clone)
2296 switch ( fromUnit )
2297 {
2298 case Qgis::VolumeUnit::CubicMeters:
2299 {
2300 switch ( toUnit )
2301 {
2302 case Qgis::VolumeUnit::CubicMeters:
2303 return 1.0;
2304 case Qgis::VolumeUnit::CubicFeet:
2305 return 35.314666572222;
2306 case Qgis::VolumeUnit::CubicYards:
2307 return 1.307950613786;
2308 case Qgis::VolumeUnit::Barrel:
2309 return 6.2898107438466;
2310 case Qgis::VolumeUnit::CubicDecimeter:
2311 return 1000;
2312 case Qgis::VolumeUnit::Liters:
2313 return 1000;
2314 case Qgis::VolumeUnit::GallonUS:
2315 return 264.17205124156;
2316 case Qgis::VolumeUnit::CubicInch:
2317 return 61023.7438368;
2318 case Qgis::VolumeUnit::CubicCentimeter:
2319 return 1000000;
2320 case Qgis::VolumeUnit::CubicDegrees:
2321 return 1 / DEG2_TO_M3; // basically meaningless!
2322 case Qgis::VolumeUnit::Unknown:
2323 return 1.0;
2324 }
2325 break;
2326 }
2327 case Qgis::VolumeUnit::CubicFeet:
2328 {
2329 switch ( toUnit )
2330 {
2331 case Qgis::VolumeUnit::CubicMeters:
2332 return 0.028316846592;
2333 case Qgis::VolumeUnit::CubicFeet:
2334 return 1.0;
2335 case Qgis::VolumeUnit::CubicYards:
2336 return 0.037037037;
2337 case Qgis::VolumeUnit::Barrel:
2338 return 0.178107622;
2339 case Qgis::VolumeUnit::CubicDecimeter:
2340 return 28.31685;
2341 case Qgis::VolumeUnit::Liters:
2342 return 28.31685;
2343 case Qgis::VolumeUnit::GallonUS:
2344 return 7.480519954;
2345 case Qgis::VolumeUnit::CubicInch:
2346 return 1728.000629765;
2347 case Qgis::VolumeUnit::CubicCentimeter:
2348 return 28316.85;
2349 case Qgis::VolumeUnit::CubicDegrees:
2350 return 0.028316846592 / DEG2_TO_M3; // basically meaningless!
2351 case Qgis::VolumeUnit::Unknown:
2352 return 1.0;
2353 }
2354 break;
2355 }
2356 case Qgis::VolumeUnit::CubicYards:
2357 {
2358 switch ( toUnit )
2359 {
2360 case Qgis::VolumeUnit::CubicMeters:
2361 return 0.764554900;
2362 case Qgis::VolumeUnit::CubicFeet:
2363 return 26.999998234;
2364 case Qgis::VolumeUnit::CubicYards:
2365 return 1.0;
2366 case Qgis::VolumeUnit::Barrel:
2367 return 4.808905491;
2368 case Qgis::VolumeUnit::CubicDecimeter:
2369 return 764.5549;
2370 case Qgis::VolumeUnit::Liters:
2371 return 764.5549;
2372 case Qgis::VolumeUnit::GallonUS:
2373 return 201.974025549;
2374 case Qgis::VolumeUnit::CubicInch:
2375 return 46656.013952472;
2376 case Qgis::VolumeUnit::CubicCentimeter:
2377 return 764554.9;
2378 case Qgis::VolumeUnit::CubicDegrees:
2379 return 0.764554900 / DEG2_TO_M3; // basically meaningless!
2380 case Qgis::VolumeUnit::Unknown:
2381 return 1.0;
2382 }
2383 break;
2384 }
2385 case Qgis::VolumeUnit::Barrel:
2386 {
2387 switch ( toUnit )
2388 {
2389 case Qgis::VolumeUnit::CubicMeters:
2390 return 0.158987300;
2391 case Qgis::VolumeUnit::CubicFeet:
2392 return 5.614582837;
2393 case Qgis::VolumeUnit::CubicYards:
2394 return 0.207947526;
2395 case Qgis::VolumeUnit::Barrel:
2396 return 1.0;
2397 case Qgis::VolumeUnit::CubicDecimeter:
2398 return 158.9873;
2399 case Qgis::VolumeUnit::Liters:
2400 return 158.9873;
2401 case Qgis::VolumeUnit::GallonUS:
2402 return 41.999998943;
2403 case Qgis::VolumeUnit::CubicInch:
2404 return 9702.002677722;
2405 case Qgis::VolumeUnit::CubicCentimeter:
2406 return 158987.3;
2407 case Qgis::VolumeUnit::CubicDegrees:
2408 return 0.158987300 / DEG2_TO_M3; // basically meaningless!
2409 case Qgis::VolumeUnit::Unknown:
2410 return 1.0;
2411 }
2412 break;
2413 }
2414 case Qgis::VolumeUnit::CubicDecimeter:
2415 case Qgis::VolumeUnit::Liters:
2416 {
2417 switch ( toUnit )
2418 {
2419 case Qgis::VolumeUnit::CubicMeters:
2420 return 0.001;
2421 case Qgis::VolumeUnit::CubicFeet:
2422 return 0.035314662;
2423 case Qgis::VolumeUnit::CubicYards:
2424 return 0.001307951;
2425 case Qgis::VolumeUnit::Barrel:
2426 return 0.006289811;
2427 case Qgis::VolumeUnit::CubicDecimeter:
2428 case Qgis::VolumeUnit::Liters:
2429 return 1.0;
2430 case Qgis::VolumeUnit::GallonUS:
2431 return 0.264172037;
2432 case Qgis::VolumeUnit::CubicInch:
2433 return 61.023758990;
2434 case Qgis::VolumeUnit::CubicCentimeter:
2435 return 1000;
2436 case Qgis::VolumeUnit::CubicDegrees:
2437 return 0.001 / DEG2_TO_M3; // basically meaningless!
2438 case Qgis::VolumeUnit::Unknown:
2439 return 1.0;
2440 }
2441 break;
2442 }
2443 case Qgis::VolumeUnit::GallonUS:
2444 {
2445 switch ( toUnit )
2446 {
2447 case Qgis::VolumeUnit::CubicMeters:
2448 return 0.003785412;
2449 case Qgis::VolumeUnit::CubicFeet:
2450 return 0.133680547;
2451 case Qgis::VolumeUnit::CubicYards:
2452 return 0.004951132;
2453 case Qgis::VolumeUnit::Barrel:
2454 return 0.023809524;
2455 case Qgis::VolumeUnit::CubicDecimeter:
2456 case Qgis::VolumeUnit::Liters:
2457 return 3.785412000;
2458 case Qgis::VolumeUnit::GallonUS:
2459 return 1.0;
2460 case Qgis::VolumeUnit::CubicInch:
2461 return 231.000069567;
2462 case Qgis::VolumeUnit::CubicCentimeter:
2463 return 3785.412;
2464 case Qgis::VolumeUnit::CubicDegrees:
2465 return 0.003785412 / DEG2_TO_M3; // basically meaningless!
2466 case Qgis::VolumeUnit::Unknown:
2467 return 1.0;
2468 }
2469 break;
2470 }
2471 case Qgis::VolumeUnit::CubicInch:
2472 {
2473 switch ( toUnit )
2474 {
2475 case Qgis::VolumeUnit::CubicMeters:
2476 return 0.000016387;
2477 case Qgis::VolumeUnit::CubicFeet:
2478 return 0.000578703;
2479 case Qgis::VolumeUnit::CubicYards:
2480 return 0.000021433;
2481 case Qgis::VolumeUnit::Barrel:
2482 return 0.000103072;
2483 case Qgis::VolumeUnit::CubicDecimeter:
2484 case Qgis::VolumeUnit::Liters:
2485 return 0.016387060;
2486 case Qgis::VolumeUnit::GallonUS:
2487 return 0.004329003;
2488 case Qgis::VolumeUnit::CubicInch:
2489 return 1.0;
2490 case Qgis::VolumeUnit::CubicCentimeter:
2491 return 16.387060000;
2492 case Qgis::VolumeUnit::CubicDegrees:
2493 return 0.000016387 / DEG2_TO_M3; // basically meaningless!
2494 case Qgis::VolumeUnit::Unknown:
2495 return 1.0;
2496 }
2497 break;
2498 }
2499 case Qgis::VolumeUnit::CubicCentimeter:
2500 {
2501 switch ( toUnit )
2502 {
2503 case Qgis::VolumeUnit::CubicMeters:
2504 return 0.000001;
2505 case Qgis::VolumeUnit::CubicFeet:
2506 return 0.000035315;
2507 case Qgis::VolumeUnit::CubicYards:
2508 return 0.000001308;
2509 case Qgis::VolumeUnit::Barrel:
2510 return 0.000006290;
2511 case Qgis::VolumeUnit::CubicDecimeter:
2512 case Qgis::VolumeUnit::Liters:
2513 return 0.001;
2514 case Qgis::VolumeUnit::GallonUS:
2515 return 0.000264172 ;
2516 case Qgis::VolumeUnit::CubicInch:
2517 return 0.061023759;
2518 case Qgis::VolumeUnit::CubicCentimeter:
2519 return 1.0;
2520 case Qgis::VolumeUnit::CubicDegrees:
2521 return 0.000001 / DEG2_TO_M3; // basically meaningless!
2522 case Qgis::VolumeUnit::Unknown:
2523 return 1.0;
2524 }
2525 break;
2526 }
2527 case Qgis::VolumeUnit::CubicDegrees:
2528 if ( toUnit == Qgis::VolumeUnit::Unknown || toUnit == Qgis::VolumeUnit::CubicDegrees )
2529 return 1.0;
2530 else
2531 return fromUnitToUnitFactor( toUnit, Qgis::VolumeUnit::CubicMeters ) * DEG2_TO_M3;
2532
2533 case Qgis::VolumeUnit::Unknown:
2534 {
2535 return 1.0;
2536 }
2537 }
2538 // NOLINTEND(bugprone-branch-clone)
2539 return 1.0;
2540}
2541
2542Qgis::VolumeUnit QgsUnitTypes::distanceToVolumeUnit( Qgis::DistanceUnit distanceUnit )
2543{
2544 // cloned branches are intentional here for improved readability
2545 // NOLINTBEGIN(bugprone-branch-clone)
2546 switch ( distanceUnit )
2547 {
2548 case Qgis::DistanceUnit::Meters:
2549 case Qgis::DistanceUnit::MetersGermanLegal:
2550 return Qgis::VolumeUnit::CubicMeters;
2551
2552 case Qgis::DistanceUnit::Kilometers:
2553 return Qgis::VolumeUnit::CubicMeters;
2554
2555 case Qgis::DistanceUnit::Centimeters:
2556 return Qgis::VolumeUnit::CubicCentimeter;
2557
2558 case Qgis::DistanceUnit::Millimeters:
2559 return Qgis::VolumeUnit::CubicCentimeter;
2560
2561 case Qgis::DistanceUnit::Feet:
2562 case Qgis::DistanceUnit::FeetBritish1865:
2563 case Qgis::DistanceUnit::FeetBritish1936:
2564 case Qgis::DistanceUnit::FeetBritishBenoit1895A:
2565 case Qgis::DistanceUnit::FeetBritishBenoit1895B:
2566 case Qgis::DistanceUnit::FeetBritishSears1922Truncated:
2567 case Qgis::DistanceUnit::FeetBritishSears1922:
2568 case Qgis::DistanceUnit::FeetClarkes:
2569 case Qgis::DistanceUnit::FeetGoldCoast:
2570 case Qgis::DistanceUnit::FeetIndian:
2571 case Qgis::DistanceUnit::FeetIndian1937:
2572 case Qgis::DistanceUnit::FeetIndian1962:
2573 case Qgis::DistanceUnit::FeetIndian1975:
2574 case Qgis::DistanceUnit::FeetUSSurvey:
2575 return Qgis::VolumeUnit::CubicFeet;
2576
2577 case Qgis::DistanceUnit::Yards:
2578 case Qgis::DistanceUnit::YardsBritishBenoit1895A:
2579 case Qgis::DistanceUnit::YardsBritishBenoit1895B:
2580 case Qgis::DistanceUnit::YardsBritishSears1922Truncated:
2581 case Qgis::DistanceUnit::YardsBritishSears1922:
2582 case Qgis::DistanceUnit::YardsClarkes:
2583 case Qgis::DistanceUnit::YardsIndian:
2584 case Qgis::DistanceUnit::YardsIndian1937:
2585 case Qgis::DistanceUnit::YardsIndian1962:
2586 case Qgis::DistanceUnit::YardsIndian1975:
2587 return Qgis::VolumeUnit::CubicYards;
2588
2589 case Qgis::DistanceUnit::Miles:
2590 case Qgis::DistanceUnit::MilesUSSurvey:
2591 case Qgis::DistanceUnit::ChainsInternational:
2592 case Qgis::DistanceUnit::ChainsBritishBenoit1895A:
2593 case Qgis::DistanceUnit::ChainsBritishBenoit1895B:
2594 case Qgis::DistanceUnit::ChainsBritishSears1922Truncated:
2595 case Qgis::DistanceUnit::ChainsBritishSears1922:
2596 case Qgis::DistanceUnit::ChainsClarkes:
2597 case Qgis::DistanceUnit::ChainsUSSurvey:
2598 case Qgis::DistanceUnit::LinksInternational:
2599 case Qgis::DistanceUnit::LinksBritishBenoit1895A:
2600 case Qgis::DistanceUnit::LinksBritishBenoit1895B:
2601 case Qgis::DistanceUnit::LinksBritishSears1922Truncated:
2602 case Qgis::DistanceUnit::LinksBritishSears1922:
2603 case Qgis::DistanceUnit::LinksClarkes:
2604 case Qgis::DistanceUnit::LinksUSSurvey:
2605 case Qgis::DistanceUnit::Fathoms:
2606 return Qgis::VolumeUnit::CubicFeet;
2607
2608 case Qgis::DistanceUnit::Degrees:
2609 return Qgis::VolumeUnit::CubicDegrees;
2610
2611 case Qgis::DistanceUnit::Unknown:
2612 return Qgis::VolumeUnit::Unknown;
2613
2614 case Qgis::DistanceUnit::NauticalMiles:
2615 return Qgis::VolumeUnit::CubicFeet;
2616
2617 case Qgis::DistanceUnit::Inches:
2618 return Qgis::VolumeUnit::CubicInch;
2619 }
2620 // NOLINTEND(bugprone-branch-clone)
2621
2622 return Qgis::VolumeUnit::Unknown;
2623}
2624
2654
2676
2677QString QgsUnitTypes::encodeUnit( Qgis::VolumeUnit unit )
2678{
2679 switch ( unit )
2680 {
2681 case Qgis::VolumeUnit::CubicMeters:
2682 return QStringLiteral( "m3" );
2683 case Qgis::VolumeUnit::CubicFeet:
2684 return QStringLiteral( "ft3" );
2685 case Qgis::VolumeUnit::CubicYards:
2686 return QStringLiteral( "yd3" );
2687 case Qgis::VolumeUnit::Barrel:
2688 return QStringLiteral( "bbl" );
2689 case Qgis::VolumeUnit::CubicDecimeter:
2690 return QStringLiteral( "dm3" );
2691 case Qgis::VolumeUnit::Liters:
2692 return QStringLiteral( "l" );
2693 case Qgis::VolumeUnit::GallonUS:
2694 return QStringLiteral( "gal" );
2695 case Qgis::VolumeUnit::CubicInch:
2696 return QStringLiteral( "in3" );
2697 case Qgis::VolumeUnit::CubicCentimeter:
2698 return QStringLiteral( "cm3" );
2699 case Qgis::VolumeUnit::CubicDegrees:
2700 return QStringLiteral( "deg3" );
2701 case Qgis::VolumeUnit::Unknown:
2702 return QStringLiteral( "<unknown>" );
2703 }
2704 return QString();
2705}
2706
2707QString QgsUnitTypes::encodeUnit( Qgis::AngleUnit unit )
2708{
2709 switch ( unit )
2710 {
2711 case Qgis::AngleUnit::Degrees:
2712 return QStringLiteral( "degrees" );
2713 case Qgis::AngleUnit::Radians:
2714 return QStringLiteral( "radians" );
2715 case Qgis::AngleUnit::Gon:
2716 return QStringLiteral( "gon" );
2717 case Qgis::AngleUnit::MinutesOfArc:
2718 return QStringLiteral( "moa" );
2719 case Qgis::AngleUnit::SecondsOfArc:
2720 return QStringLiteral( "soa" );
2721 case Qgis::AngleUnit::Turn:
2722 return QStringLiteral( "tr" );
2723 case Qgis::AngleUnit::MilliradiansSI:
2724 return QStringLiteral( "milliradians" );
2725 case Qgis::AngleUnit::MilNATO:
2726 return QStringLiteral( "mil" );
2727 case Qgis::AngleUnit::Unknown:
2728 return QStringLiteral( "<unknown>" );
2729 }
2730 return QString();
2731}
2732
2733Qgis::AngleUnit QgsUnitTypes::decodeAngleUnit( const QString &string, bool *ok )
2734{
2735 const QString normalized = string.trimmed().toLower();
2736
2737 if ( ok )
2738 *ok = true;
2739
2740 if ( normalized == encodeUnit( Qgis::AngleUnit::Degrees ) )
2741 return Qgis::AngleUnit::Degrees;
2742 if ( normalized == encodeUnit( Qgis::AngleUnit::Radians ) )
2743 return Qgis::AngleUnit::Radians;
2744 if ( normalized == encodeUnit( Qgis::AngleUnit::Gon ) )
2745 return Qgis::AngleUnit::Gon;
2746 if ( normalized == encodeUnit( Qgis::AngleUnit::MinutesOfArc ) )
2747 return Qgis::AngleUnit::MinutesOfArc;
2748 if ( normalized == encodeUnit( Qgis::AngleUnit::SecondsOfArc ) )
2749 return Qgis::AngleUnit::SecondsOfArc;
2750 if ( normalized == encodeUnit( Qgis::AngleUnit::Turn ) )
2751 return Qgis::AngleUnit::Turn;
2752 if ( normalized == encodeUnit( Qgis::AngleUnit::MilliradiansSI ) )
2753 return Qgis::AngleUnit::MilliradiansSI;
2754 if ( normalized == encodeUnit( Qgis::AngleUnit::MilNATO ) )
2755 return Qgis::AngleUnit::MilNATO;
2756 if ( normalized == encodeUnit( Qgis::AngleUnit::Unknown ) )
2757 return Qgis::AngleUnit::Unknown;
2758 if ( ok )
2759 *ok = false;
2760
2761 return Qgis::AngleUnit::Unknown;
2762}
2763
2764QString QgsUnitTypes::toString( Qgis::AngleUnit unit )
2765{
2766 switch ( unit )
2767 {
2768 case Qgis::AngleUnit::Degrees:
2769 return QObject::tr( "degrees", "angle" );
2770 case Qgis::AngleUnit::Radians:
2771 return QObject::tr( "radians", "angle" );
2772 case Qgis::AngleUnit::Gon:
2773 return QObject::tr( "gon", "angle" );
2774 case Qgis::AngleUnit::MinutesOfArc:
2775 return QObject::tr( "minutes of arc", "angle" );
2776 case Qgis::AngleUnit::SecondsOfArc:
2777 return QObject::tr( "seconds of arc", "angle" );
2778 case Qgis::AngleUnit::Turn:
2779 return QObject::tr( "turns", "angle" );
2780 case Qgis::AngleUnit::MilliradiansSI:
2781 return QObject::tr( "milliradians", "angle" );
2782 case Qgis::AngleUnit::MilNATO:
2783 return QObject::tr( "mil", "angle" );
2784 case Qgis::AngleUnit::Unknown:
2785 return QObject::tr( "<unknown>", "angle" );
2786 }
2787 return QString();
2788}
2789
2790double QgsUnitTypes::fromUnitToUnitFactor( Qgis::AngleUnit fromUnit, Qgis::AngleUnit toUnit )
2791{
2792 // Calculate the conversion factor between the specified units
2793 switch ( fromUnit )
2794 {
2795 case Qgis::AngleUnit::Degrees:
2796 {
2797 switch ( toUnit )
2798 {
2799 case Qgis::AngleUnit::Degrees:
2800 return 1.0;
2801 case Qgis::AngleUnit::Radians:
2802 return M_PI / 180.0;
2803 case Qgis::AngleUnit::Gon:
2804 return 400.0 / 360.0;
2805 case Qgis::AngleUnit::MinutesOfArc:
2806 return 60;
2807 case Qgis::AngleUnit::SecondsOfArc:
2808 return 3600;
2809 case Qgis::AngleUnit::Turn:
2810 return 1.0 / 360.0;
2811 case Qgis::AngleUnit::MilliradiansSI:
2812 return M_PI / 180.0 * 1000;
2813 case Qgis::AngleUnit::MilNATO:
2814 return 3200.0 / 180;
2815 case Qgis::AngleUnit::Unknown:
2816 break;
2817 }
2818 break;
2819 }
2820 case Qgis::AngleUnit::Radians:
2821 {
2822 switch ( toUnit )
2823 {
2824 case Qgis::AngleUnit::Degrees:
2825 return 180.0 / M_PI;
2826 case Qgis::AngleUnit::Radians:
2827 return 1.0;
2828 case Qgis::AngleUnit::Gon:
2829 return 200.0 / M_PI;
2830 case Qgis::AngleUnit::MinutesOfArc:
2831 return 60 * 180.0 / M_PI;
2832 case Qgis::AngleUnit::SecondsOfArc:
2833 return 3600 * 180.0 / M_PI;
2834 case Qgis::AngleUnit::Turn:
2835 return 0.5 / M_PI;
2836 case Qgis::AngleUnit::MilliradiansSI:
2837 return 1000;
2838 case Qgis::AngleUnit::MilNATO:
2839 return 3200.0 / M_PI;
2840 case Qgis::AngleUnit::Unknown:
2841 break;
2842 }
2843 break;
2844 }
2845 case Qgis::AngleUnit::Gon:
2846 {
2847 switch ( toUnit )
2848 {
2849 case Qgis::AngleUnit::Degrees:
2850 return 360.0 / 400.0;
2851 case Qgis::AngleUnit::Radians:
2852 return M_PI / 200.0;
2853 case Qgis::AngleUnit::Gon:
2854 return 1.0;
2855 case Qgis::AngleUnit::MinutesOfArc:
2856 return 60 * 360.0 / 400.0;
2857 case Qgis::AngleUnit::SecondsOfArc:
2858 return 3600 * 360.0 / 400.0;
2859 case Qgis::AngleUnit::Turn:
2860 return 1.0 / 400.0;
2861 case Qgis::AngleUnit::MilliradiansSI:
2862 return M_PI / 200.0 * 1000;
2863 case Qgis::AngleUnit::MilNATO:
2864 return 3200.0 / 200.0;
2865 case Qgis::AngleUnit::Unknown:
2866 break;
2867 }
2868 break;
2869 }
2870 case Qgis::AngleUnit::MinutesOfArc:
2871 {
2872 switch ( toUnit )
2873 {
2874 case Qgis::AngleUnit::Degrees:
2875 return 1 / 60.0;
2876 case Qgis::AngleUnit::Radians:
2877 return M_PI / 180.0 / 60.0;
2878 case Qgis::AngleUnit::Gon:
2879 return 400.0 / 360.0 / 60.0;
2880 case Qgis::AngleUnit::MinutesOfArc:
2881 return 1.0;
2882 case Qgis::AngleUnit::SecondsOfArc:
2883 return 60.0;
2884 case Qgis::AngleUnit::Turn:
2885 return 1.0 / 360.0 / 60.0;
2886 case Qgis::AngleUnit::MilliradiansSI:
2887 return M_PI / 180.0 / 60.0 * 1000;
2888 case Qgis::AngleUnit::MilNATO:
2889 return 3200.0 / 180.0 / 60.0;
2890 case Qgis::AngleUnit::Unknown:
2891 break;
2892 }
2893 break;
2894 }
2895 case Qgis::AngleUnit::SecondsOfArc:
2896 {
2897 switch ( toUnit )
2898 {
2899 case Qgis::AngleUnit::Degrees:
2900 return 1 / 3600.0;
2901 case Qgis::AngleUnit::Radians:
2902 return M_PI / 180.0 / 3600.0;
2903 case Qgis::AngleUnit::Gon:
2904 return 400.0 / 360.0 / 3600.0;
2905 case Qgis::AngleUnit::MinutesOfArc:
2906 return 1.0 / 60.0;
2907 case Qgis::AngleUnit::SecondsOfArc:
2908 return 1.0;
2909 case Qgis::AngleUnit::Turn:
2910 return 1.0 / 360.0 / 3600.0;
2911 case Qgis::AngleUnit::MilliradiansSI:
2912 return M_PI / 180.0 / 3600.0 * 1000;
2913 case Qgis::AngleUnit::MilNATO:
2914 return 3200.0 / 180.0 / 3600.0;
2915 case Qgis::AngleUnit::Unknown:
2916 break;
2917 }
2918 break;
2919 }
2920 case Qgis::AngleUnit::Turn:
2921 {
2922 switch ( toUnit )
2923 {
2924 case Qgis::AngleUnit::Degrees:
2925 return 360.0;
2926 case Qgis::AngleUnit::Radians:
2927 return 2 * M_PI;
2928 case Qgis::AngleUnit::Gon:
2929 return 400.0;
2930 case Qgis::AngleUnit::MinutesOfArc:
2931 return 360.0 * 60.0;
2932 case Qgis::AngleUnit::SecondsOfArc:
2933 return 360.0 * 3600.0;
2934 case Qgis::AngleUnit::Turn:
2935 return 1.0;
2936 case Qgis::AngleUnit::MilliradiansSI:
2937 return 2 * M_PI * 1000;
2938 case Qgis::AngleUnit::MilNATO:
2939 return 2 * 3200;
2940 case Qgis::AngleUnit::Unknown:
2941 break;
2942 }
2943 break;
2944 }
2945 case Qgis::AngleUnit::MilliradiansSI:
2946 {
2947 switch ( toUnit )
2948 {
2949 case Qgis::AngleUnit::Degrees:
2950 return 180.0 / M_PI / 1000;
2951 case Qgis::AngleUnit::Radians:
2952 return 0.001;
2953 case Qgis::AngleUnit::Gon:
2954 return 200.0 / M_PI / 1000;
2955 case Qgis::AngleUnit::MinutesOfArc:
2956 return 180.0 * 60.0 / M_PI / 1000;
2957 case Qgis::AngleUnit::SecondsOfArc:
2958 return 180.0 * 3600.0 / M_PI / 1000;
2959 case Qgis::AngleUnit::Turn:
2960 return M_PI / 2 / 1000;
2961 case Qgis::AngleUnit::MilliradiansSI:
2962 return 1.0;
2963 case Qgis::AngleUnit::MilNATO:
2964 return 3200.0 / 1000.0 / M_PI;
2965 case Qgis::AngleUnit::Unknown:
2966 break;
2967 }
2968 break;
2969 }
2970
2971 case Qgis::AngleUnit::MilNATO:
2972 {
2973 switch ( toUnit )
2974 {
2975 case Qgis::AngleUnit::Degrees:
2976 return 180.0 / 3200;
2977 case Qgis::AngleUnit::Radians:
2978 return M_PI / 3200;
2979 case Qgis::AngleUnit::Gon:
2980 return 200.0 / 3200;
2981 case Qgis::AngleUnit::MinutesOfArc:
2982 return 60 * 180.0 / 3200;
2983 case Qgis::AngleUnit::SecondsOfArc:
2984 return 3600.0 * 180 / 3200;
2985 case Qgis::AngleUnit::Turn:
2986 return 1.0 / ( 2 * 32000 );
2987 case Qgis::AngleUnit::MilliradiansSI:
2988 return 1000.0 * M_PI / 3200.0;
2989 case Qgis::AngleUnit::MilNATO:
2990 return 1.0;
2991 case Qgis::AngleUnit::Unknown:
2992 break;
2993 }
2994 break;
2995 }
2996
2997 case Qgis::AngleUnit::Unknown:
2998 break;
2999 }
3000 return 1.0;
3001}
3002
3003QString QgsUnitTypes::formatAngle( double angle, int decimals, Qgis::AngleUnit unit )
3004{
3005 QString unitLabel;
3006 int decimalPlaces = 2;
3007
3008 switch ( unit )
3009 {
3010 case Qgis::AngleUnit::Degrees:
3011 unitLabel = QObject::tr( "°", "angle" );
3012 decimalPlaces = 0;
3013 break;
3014 case Qgis::AngleUnit::Radians:
3015 unitLabel = QObject::tr( " rad", "angle" );
3016 decimalPlaces = 2;
3017 break;
3018 case Qgis::AngleUnit::Gon:
3019 unitLabel = QObject::tr( " gon", "angle" );
3020 decimalPlaces = 0;
3021 break;
3022 case Qgis::AngleUnit::MinutesOfArc:
3023 unitLabel = QObject::tr( "′", "angle minutes" );
3024 decimalPlaces = 0;
3025 break;
3026 case Qgis::AngleUnit::SecondsOfArc:
3027 unitLabel = QObject::tr( "″", "angle seconds" );
3028 decimalPlaces = 0;
3029 break;
3030 case Qgis::AngleUnit::Turn:
3031 unitLabel = QObject::tr( " tr", "angle turn" );
3032 decimalPlaces = 3;
3033 break;
3034 case Qgis::AngleUnit::MilliradiansSI:
3035 unitLabel = QObject::tr( " millirad", "angular mil SI" );
3036 decimalPlaces = 0;
3037 break;
3038 case Qgis::AngleUnit::MilNATO:
3039 unitLabel = QObject::tr( " mil", "angular mil NATO" );
3040 decimalPlaces = 0;
3041 break;
3042 case Qgis::AngleUnit::Unknown:
3043 break;
3044 }
3045
3046 if ( decimals >= 0 )
3047 decimalPlaces = decimals;
3048
3049 return QStringLiteral( "%L1%2" ).arg( angle, 0, 'f', decimalPlaces ).arg( unitLabel );
3050}
3051
3052QgsUnitTypes::DistanceValue QgsUnitTypes::scaledDistance( double distance, Qgis::DistanceUnit unit, int decimals, bool keepBaseUnit )
3053{
3054 DistanceValue result;
3055
3056 // cloned branches are intentional here for improved readability
3057 // NOLINTBEGIN(bugprone-branch-clone)
3058 switch ( unit )
3059 {
3060 case Qgis::DistanceUnit::Meters:
3061 if ( keepBaseUnit )
3062 {
3063 result.value = qgsRound( distance, decimals );
3064 result.unit = Qgis::DistanceUnit::Meters;
3065 }
3066 else if ( std::fabs( distance ) > 1000.0 )
3067 {
3068 result.value = qgsRound( distance / 1000, decimals );
3069 result.unit = Qgis::DistanceUnit::Kilometers;
3070 }
3071 else if ( std::fabs( distance ) < 0.01 )
3072 {
3073 result.value = qgsRound( distance * 1000, decimals );
3074 result.unit = Qgis::DistanceUnit::Millimeters;
3075 }
3076 else if ( std::fabs( distance ) < 0.1 )
3077 {
3078
3079 result.value = qgsRound( distance * 100, decimals );
3080 result.unit = Qgis::DistanceUnit::Centimeters;
3081 }
3082 else
3083 {
3084 result.value = qgsRound( distance, decimals );
3085 result.unit = Qgis::DistanceUnit::Meters;
3086 }
3087 break;
3088
3089 case Qgis::DistanceUnit::Kilometers:
3090 if ( keepBaseUnit || std::fabs( distance ) >= 1.0 )
3091 {
3092 result.value = qgsRound( distance, decimals );
3093 result.unit = Qgis::DistanceUnit::Kilometers;
3094 }
3095 else
3096 {
3097 result.value = qgsRound( distance * 1000, decimals );
3098 result.unit = Qgis::DistanceUnit::Meters;
3099 }
3100 break;
3101
3102 case Qgis::DistanceUnit::Feet:
3103 if ( std::fabs( distance ) <= 5280.0 || keepBaseUnit )
3104 {
3105 result.value = qgsRound( distance, decimals );
3106 result.unit = Qgis::DistanceUnit::Feet;
3107 }
3108 else
3109 {
3110 result.value = qgsRound( distance / 5280.0, decimals );
3111 result.unit = Qgis::DistanceUnit::Miles;
3112 }
3113 break;
3114
3115 case Qgis::DistanceUnit::Yards:
3116 if ( std::fabs( distance ) <= 1760.0 || keepBaseUnit )
3117 {
3118 result.value = qgsRound( distance, decimals );
3119 result.unit = Qgis::DistanceUnit::Yards;
3120 }
3121 else
3122 {
3123 result.value = qgsRound( distance / 1760.0, decimals );
3124 result.unit = Qgis::DistanceUnit::Miles;
3125 }
3126 break;
3127
3128 case Qgis::DistanceUnit::Miles:
3129 if ( std::fabs( distance ) >= 1.0 || keepBaseUnit )
3130 {
3131 result.value = qgsRound( distance, decimals );
3132 result.unit = Qgis::DistanceUnit::Miles;
3133 }
3134 else
3135 {
3136 result.value = qgsRound( distance * 5280.0, decimals );
3137 result.unit = Qgis::DistanceUnit::Feet;
3138 }
3139 break;
3140
3141 case Qgis::DistanceUnit::NauticalMiles:
3142 result.value = qgsRound( distance, decimals );
3143 result.unit = Qgis::DistanceUnit::NauticalMiles;
3144 break;
3145
3146 case Qgis::DistanceUnit::Degrees:
3147 result.value = qgsRound( distance, decimals );
3148 result.unit = Qgis::DistanceUnit::Degrees;
3149 break;
3150
3151 case Qgis::DistanceUnit::Unknown:
3152 result.value = qgsRound( distance, decimals );
3153 result.unit = Qgis::DistanceUnit::Unknown;
3154 break;
3155
3156 default:
3157 result.value = qgsRound( distance, decimals );
3158 result.unit = unit;
3159 break;
3160 }
3161 // NOLINTEND(bugprone-branch-clone)
3162
3163 return result;
3164}
3165
3166QgsUnitTypes::AreaValue QgsUnitTypes::scaledArea( double area, Qgis::AreaUnit unit, int decimals, bool keepBaseUnit )
3167{
3168 QgsUnitTypes::AreaValue result;
3169 result.value = -1.0;
3170 result.unit = Qgis::AreaUnit::Unknown;
3171
3172 // If we are not forced to keep the base units, switch to meter calculation
3173 if ( unit == Qgis::AreaUnit::SquareMillimeters )
3174 {
3175 if ( keepBaseUnit )
3176 {
3177 result.value = qgsRound( area, decimals );
3178 result.unit = Qgis::AreaUnit::SquareMillimeters;
3179 }
3180 else
3181 {
3182 area /= 1000000.0;
3183 unit = Qgis::AreaUnit::SquareMeters;
3184 }
3185 }
3186 else if ( unit == Qgis::AreaUnit::SquareCentimeters )
3187 {
3188 if ( keepBaseUnit )
3189 {
3190 result.value = qgsRound( area, decimals );
3191 result.unit = Qgis::AreaUnit::SquareCentimeters;
3192 }
3193 else
3194 {
3195 area /= 10000.0;
3196 unit = Qgis::AreaUnit::SquareMeters;
3197 }
3198 }
3199
3200 // cloned branches are intentional here for improved readability
3201 // NOLINTBEGIN(bugprone-branch-clone)
3202 switch ( unit )
3203 {
3204 case Qgis::AreaUnit::SquareCentimeters:
3205 // handled in the if above
3206 break;
3207 case Qgis::AreaUnit::SquareMillimeters:
3208 // handled in the if above
3209 break;
3210 case Qgis::AreaUnit::SquareMeters:
3211 {
3212 if ( keepBaseUnit )
3213 {
3214 result.value = qgsRound( area, decimals );
3215 result.unit = Qgis::AreaUnit::SquareMeters;
3216 }
3217 else if ( std::fabs( area ) > QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareKilometers, Qgis::AreaUnit::SquareMeters ) )
3218 {
3219 result.value = qgsRound( area * QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareMeters, Qgis::AreaUnit::SquareKilometers ), decimals );
3220 result.unit = Qgis::AreaUnit::SquareKilometers;
3221 }
3222 else if ( std::fabs( area ) > QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::Hectares, Qgis::AreaUnit::SquareMeters ) )
3223 {
3224 result.value = qgsRound( area * QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareMeters, Qgis::AreaUnit::Hectares ), decimals );
3225 result.unit = Qgis::AreaUnit::Hectares;
3226 }
3227 else
3228 {
3229 result.value = qgsRound( area, decimals );
3230 result.unit = Qgis::AreaUnit::SquareMeters;
3231 }
3232 break;
3233 }
3234
3235 case Qgis::AreaUnit::SquareKilometers:
3236 {
3237 result.value = qgsRound( area, decimals );
3238 result.unit = Qgis::AreaUnit::SquareKilometers;
3239 break;
3240 }
3241
3242 case Qgis::AreaUnit::SquareInches:
3243 {
3244 result.value = qgsRound( area, decimals );
3245 result.unit = Qgis::AreaUnit::SquareInches;
3246 break;
3247 }
3248
3249 case Qgis::AreaUnit::SquareFeet:
3250 {
3251 if ( keepBaseUnit )
3252 {
3253 result.value = qgsRound( area, decimals );
3254 result.unit = Qgis::AreaUnit::SquareFeet;
3255 }
3256 else if ( std::fabs( area ) > QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareMiles, Qgis::AreaUnit::SquareFeet ) )
3257 {
3258 result.value = qgsRound( area * QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareFeet, Qgis::AreaUnit::SquareMiles ), decimals );
3259 result.unit = Qgis::AreaUnit::SquareMiles;
3260 }
3261 else
3262 {
3263 result.value = qgsRound( area, decimals );
3264 result.unit = Qgis::AreaUnit::SquareFeet;
3265 }
3266 break;
3267 }
3268
3269 case Qgis::AreaUnit::SquareYards:
3270 {
3271 if ( keepBaseUnit )
3272 {
3273 result.value = qgsRound( area, decimals );
3274 result.unit = Qgis::AreaUnit::SquareYards;
3275 }
3276 else if ( std::fabs( area ) > QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareMiles, Qgis::AreaUnit::SquareYards ) )
3277 {
3278 result.value = qgsRound( area * QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareYards, Qgis::AreaUnit::SquareMiles ), decimals );
3279 result.unit = Qgis::AreaUnit::SquareMiles;
3280 }
3281 else
3282 {
3283 result.value = qgsRound( area, decimals );
3284 result.unit = Qgis::AreaUnit::SquareYards;
3285 }
3286 break;
3287 }
3288
3289 case Qgis::AreaUnit::SquareMiles:
3290 {
3291 result.value = qgsRound( area, decimals );
3292 result.unit = Qgis::AreaUnit::SquareMiles;
3293 break;
3294 }
3295
3296 case Qgis::AreaUnit::Hectares:
3297 {
3298 if ( keepBaseUnit )
3299 {
3300 result.value = qgsRound( area, decimals );
3301 result.unit = Qgis::AreaUnit::Hectares;
3302 }
3303 else if ( std::fabs( area ) > QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareKilometers, Qgis::AreaUnit::Hectares ) )
3304 {
3305 result.value = qgsRound( area * QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::Hectares, Qgis::AreaUnit::SquareKilometers ), decimals );
3306 result.unit = Qgis::AreaUnit::SquareKilometers;
3307 }
3308 else
3309 {
3310 result.value = qgsRound( area, decimals );
3311 result.unit = Qgis::AreaUnit::Hectares;
3312 }
3313 break;
3314 }
3315
3316 case Qgis::AreaUnit::Acres:
3317 {
3318 if ( keepBaseUnit )
3319 {
3320 result.value = qgsRound( area, decimals );
3321 result.unit = Qgis::AreaUnit::Acres;
3322 }
3323 else if ( std::fabs( area ) > QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::SquareMiles, Qgis::AreaUnit::Acres ) )
3324 {
3325 result.value = qgsRound( area * QgsUnitTypes::fromUnitToUnitFactor( Qgis::AreaUnit::Acres, Qgis::AreaUnit::SquareMiles ), decimals );
3326 result.unit = Qgis::AreaUnit::SquareMiles;
3327 }
3328 else
3329 {
3330 result.value = qgsRound( area, decimals );
3331 result.unit = Qgis::AreaUnit::Acres;
3332 }
3333 break;
3334 }
3335
3336 case Qgis::AreaUnit::SquareNauticalMiles:
3337 {
3338 result.value = qgsRound( area, decimals );
3339 result.unit = Qgis::AreaUnit::SquareNauticalMiles;
3340 break;
3341 }
3342
3343 case Qgis::AreaUnit::SquareDegrees:
3344 {
3345 result.value = qgsRound( area, decimals );
3346 result.unit = Qgis::AreaUnit::SquareDegrees;
3347 break;
3348 }
3349
3350 case Qgis::AreaUnit::Unknown:
3351 {
3352 result.value = qgsRound( area, decimals );
3353 result.unit = Qgis::AreaUnit::Unknown;
3354 break;
3355 }
3356 }
3357 // NOLINTEND(bugprone-branch-clone)
3358 return result;
3359}
3360
3361
3362QString QgsUnitTypes::formatDistance( double distance, int decimals, Qgis::DistanceUnit unit, bool keepBaseUnit )
3363{
3364 const DistanceValue dist = scaledDistance( distance, unit, decimals, keepBaseUnit );
3365
3366 QString unitText;
3367
3368 if ( dist.unit != Qgis::DistanceUnit::Unknown )
3369 unitText = QChar( ' ' ) + QgsUnitTypes::toAbbreviatedString( dist.unit );
3370
3371 if ( qgsDoubleNear( dist.value, 0 ) )
3372 {
3373 unitText = QChar( ' ' ) + QgsUnitTypes::toAbbreviatedString( unit );
3374 return QStringLiteral( "%L1%2" ).arg( distance, 0, 'e', decimals ).arg( unitText );
3375 }
3376 else
3377 {
3378 return QStringLiteral( "%L1%2" ).arg( dist.value, 0, 'f', decimals ).arg( unitText );
3379 }
3380}
3381
3382QString QgsUnitTypes::formatArea( double area, int decimals, Qgis::AreaUnit unit, bool keepBaseUnit )
3383{
3384 const QgsUnitTypes::AreaValue areaValue = scaledArea( area, unit, decimals, keepBaseUnit );
3385
3386 QString unitText;
3387
3388 if ( areaValue.unit != Qgis::AreaUnit::Unknown )
3389 unitText = QChar( ' ' ) + QgsUnitTypes::toAbbreviatedString( areaValue.unit );
3390
3391 if ( qgsDoubleNear( areaValue.value, 0 ) )
3392 {
3393 unitText = QChar( ' ' ) + QgsUnitTypes::toAbbreviatedString( unit );
3394 return QStringLiteral( "%L1%2" ).arg( area, 0, 'e', decimals ).arg( unitText );
3395 }
3396 else
3397 {
3398 return QStringLiteral( "%L1%2" ).arg( areaValue.value, 0, 'f', decimals ).arg( unitText );
3399 }
3400}
3401
3402QString QgsUnitTypes::encodeUnit( Qgis::RenderUnit unit )
3403{
3404 switch ( unit )
3405 {
3406 case Qgis::RenderUnit::Millimeters:
3407 return QStringLiteral( "MM" );
3408 case Qgis::RenderUnit::MetersInMapUnits:
3409 return QStringLiteral( "RenderMetersInMapUnits" );
3410 case Qgis::RenderUnit::MapUnits:
3411 return QStringLiteral( "MapUnit" );
3412 case Qgis::RenderUnit::Pixels:
3413 return QStringLiteral( "Pixel" );
3414 case Qgis::RenderUnit::Percentage:
3415 return QStringLiteral( "Percentage" );
3416 case Qgis::RenderUnit::Points:
3417 return QStringLiteral( "Point" );
3418 case Qgis::RenderUnit::Inches:
3419 return QStringLiteral( "Inch" );
3420 case Qgis::RenderUnit::Unknown:
3421 return QString();
3422 }
3423 return QString();
3424}
3425
3426Qgis::RenderUnit QgsUnitTypes::decodeRenderUnit( const QString &string, bool *ok )
3427{
3428 const QString normalized = string.trimmed().toLower();
3429
3430 if ( ok )
3431 *ok = true;
3432
3433 if ( normalized == encodeUnit( Qgis::RenderUnit::Millimeters ).toLower() )
3434 return Qgis::RenderUnit::Millimeters;
3435 if ( normalized == encodeUnit( Qgis::RenderUnit::MetersInMapUnits ).toLower() )
3436 return Qgis::RenderUnit::MetersInMapUnits;
3437 if ( normalized == QLatin1String( "meters" ) )
3438 return Qgis::RenderUnit::MetersInMapUnits;
3439 if ( normalized == encodeUnit( Qgis::RenderUnit::MapUnits ).toLower() )
3440 return Qgis::RenderUnit::MapUnits;
3441 if ( normalized == QLatin1String( "mapunits" ) )
3442 return Qgis::RenderUnit::MapUnits;
3443 if ( normalized == encodeUnit( Qgis::RenderUnit::Pixels ).toLower() )
3444 return Qgis::RenderUnit::Pixels;
3445 if ( normalized == encodeUnit( Qgis::RenderUnit::Percentage ).toLower() )
3446 return Qgis::RenderUnit::Percentage;
3447 if ( normalized == QLatin1String( "percent" ) )
3448 return Qgis::RenderUnit::Percentage;
3449 if ( normalized == encodeUnit( Qgis::RenderUnit::Points ).toLower() )
3450 return Qgis::RenderUnit::Points;
3451 if ( normalized == QLatin1String( "points" ) )
3452 return Qgis::RenderUnit::Points;
3453 if ( normalized == encodeUnit( Qgis::RenderUnit::Inches ).toLower() )
3454 return Qgis::RenderUnit::Inches;
3455
3456 if ( ok )
3457 *ok = false;
3458
3459 // millimeters are default
3460 return Qgis::RenderUnit::Millimeters;
3461}
3462
3463QString QgsUnitTypes::toString( Qgis::RenderUnit unit )
3464{
3465 switch ( unit )
3466 {
3467 case Qgis::RenderUnit::Millimeters:
3468 return QObject::tr( "millimeters", "render" );
3469
3470 case Qgis::RenderUnit::MetersInMapUnits:
3471 return QObject::tr( "meters at scale", "render" );
3472
3473 case Qgis::RenderUnit::MapUnits:
3474 return QObject::tr( "map units", "render" );
3475
3476 case Qgis::RenderUnit::Pixels:
3477 return QObject::tr( "pixels", "render" );
3478
3479 case Qgis::RenderUnit::Percentage:
3480 return QObject::tr( "percent", "render" );
3481
3482 case Qgis::RenderUnit::Points:
3483 return QObject::tr( "points", "render" );
3484
3485 case Qgis::RenderUnit::Inches:
3486 return QObject::tr( "inches", "render" );
3487
3488 case Qgis::RenderUnit::Unknown:
3489 return QObject::tr( "<unknown>", "render" );
3490
3491 }
3492 return QString();
3493}
3494
3495
3496
3497QString QgsUnitTypes::encodeUnit( Qgis::LayoutUnit unit )
3498{
3499 switch ( unit )
3500 {
3501 case Qgis::LayoutUnit::Centimeters:
3502 return QStringLiteral( "cm" );
3503 case Qgis::LayoutUnit::Meters:
3504 return QStringLiteral( "m" );
3505 case Qgis::LayoutUnit::Inches:
3506 return QStringLiteral( "in" );
3507 case Qgis::LayoutUnit::Feet:
3508 return QStringLiteral( "ft" );
3509 case Qgis::LayoutUnit::Points:
3510 return QStringLiteral( "pt" );
3511 case Qgis::LayoutUnit::Picas:
3512 return QStringLiteral( "pi" );
3513 case Qgis::LayoutUnit::Pixels:
3514 return QStringLiteral( "px" );
3515 case Qgis::LayoutUnit::Millimeters:
3516 return QStringLiteral( "mm" );
3517 }
3518 return QString();
3519}
3520
3521Qgis::LayoutUnit QgsUnitTypes::decodeLayoutUnit( const QString &string, bool *ok )
3522{
3523 const QString normalized = string.trimmed().toLower();
3524
3525 if ( ok )
3526 *ok = true;
3527
3528 if ( normalized == encodeUnit( Qgis::LayoutUnit::Millimeters ).toLower() )
3529 return Qgis::LayoutUnit::Millimeters;
3530 if ( normalized == encodeUnit( Qgis::LayoutUnit::Centimeters ).toLower() )
3531 return Qgis::LayoutUnit::Centimeters;
3532 if ( normalized == encodeUnit( Qgis::LayoutUnit::Meters ).toLower() )
3533 return Qgis::LayoutUnit::Meters;
3534 if ( normalized == encodeUnit( Qgis::LayoutUnit::Inches ).toLower() )
3535 return Qgis::LayoutUnit::Inches;
3536 if ( normalized == encodeUnit( Qgis::LayoutUnit::Feet ).toLower() )
3537 return Qgis::LayoutUnit::Feet;
3538 if ( normalized == encodeUnit( Qgis::LayoutUnit::Points ).toLower() )
3539 return Qgis::LayoutUnit::Points;
3540 if ( normalized == encodeUnit( Qgis::LayoutUnit::Picas ).toLower() )
3541 return Qgis::LayoutUnit::Picas;
3542 if ( normalized == encodeUnit( Qgis::LayoutUnit::Pixels ).toLower() )
3543 return Qgis::LayoutUnit::Pixels;
3544
3545 if ( ok )
3546 *ok = false;
3547
3548 // millimeters are default
3549 return Qgis::LayoutUnit::Millimeters;
3550}
3551
3571
3572QString QgsUnitTypes::toAbbreviatedString( Qgis::LayoutUnit unit )
3573{
3574 switch ( unit )
3575 {
3576 case Qgis::LayoutUnit::Pixels:
3577 return QObject::tr( "px" );
3578 case Qgis::LayoutUnit::Millimeters:
3579 return QObject::tr( "mm" );
3580 case Qgis::LayoutUnit::Centimeters:
3581 return QObject::tr( "cm" );
3582 case Qgis::LayoutUnit::Meters:
3583 return QObject::tr( "m" );
3584 case Qgis::LayoutUnit::Inches:
3585 return QObject::tr( "in", "unit inch" );
3586 case Qgis::LayoutUnit::Feet:
3587 return QObject::tr( "ft" );
3588 case Qgis::LayoutUnit::Points:
3589 return QObject::tr( "pt" );
3590 case Qgis::LayoutUnit::Picas:
3591 return QObject::tr( "pica" );
3592 }
3593 return QString(); // no warnings
3594}
3595
3596QString QgsUnitTypes::toString( Qgis::LayoutUnit unit )
3597{
3598 switch ( unit )
3599 {
3600 case Qgis::LayoutUnit::Pixels:
3601 return QObject::tr( "pixels" );
3602 case Qgis::LayoutUnit::Millimeters:
3603 return QObject::tr( "millimeters" );
3604 case Qgis::LayoutUnit::Centimeters:
3605 return QObject::tr( "centimeters" );
3606 case Qgis::LayoutUnit::Meters:
3607 return QObject::tr( "meters" );
3608 case Qgis::LayoutUnit::Inches:
3609 return QObject::tr( "inches" );
3610 case Qgis::LayoutUnit::Feet:
3611 return QObject::tr( "feet" );
3612 case Qgis::LayoutUnit::Points:
3613 return QObject::tr( "points" );
3614 case Qgis::LayoutUnit::Picas:
3615 return QObject::tr( "picas" );
3616 }
3617 return QString(); // no warnings
3618}
Qgis::DistanceUnitType
DistanceUnitType
Types of distance units.
Definition qgis.h:4731
Qgis::DistanceUnitType::Geographic
@ Geographic
Unit is a geographic (e.g., degree based) unit.
Qgis::DistanceUnitType::Unknown
@ Unknown
Unknown unit type.
Qgis::DistanceUnitType::Standard
@ Standard
Unit is a standard measurement unit.
Qgis::UnitType
UnitType
Unit types.
Definition qgis.h:4652
Qgis::UnitType::Distance
@ Distance
Distance unit.
Qgis::UnitType::Temporal
@ Temporal
Temporal unit.
Qgis::UnitType::Unknown
@ Unknown
Unknown unit type.
Qgis::UnitType::Volume
@ Volume
Volume unit.
Qgis::UnitType::Area
@ Area
Area unit.
Qgis::LayoutUnit
LayoutUnit
Layout measurement units.
Definition qgis.h:4859
Qgis::LayoutUnit::Centimeters
@ Centimeters
Centimeters.
Qgis::LayoutUnit::Millimeters
@ Millimeters
Millimeters.
Qgis::LayoutUnit::Points
@ Points
Typographic points.
Qgis::LayoutUnit::Picas
@ Picas
Typographic picas.
Qgis::AngleUnit
AngleUnit
Units of angles.
Definition qgis.h:4794
Qgis::AngleUnit::SecondsOfArc
@ SecondsOfArc
Seconds of arc.
Qgis::AngleUnit::Radians
@ Radians
Square kilometers.
Qgis::AngleUnit::Turn
@ Turn
Turn/revolutions.
Qgis::AngleUnit::MinutesOfArc
@ MinutesOfArc
Minutes of arc.
Qgis::AngleUnit::Unknown
@ Unknown
Unknown angle unit.
Qgis::AngleUnit::MilliradiansSI
@ MilliradiansSI
Angular milliradians (SI definition, 1/1000 of radian)
Qgis::AngleUnit::Degrees
@ Degrees
Degrees.
Qgis::AngleUnit::Gon
@ Gon
Gon/gradian.
Qgis::AngleUnit::MilNATO
@ MilNATO
Angular mil (NATO definition, 6400 mil = 2PI radians)
Qgis::DistanceUnit
DistanceUnit
Units of distance.
Definition qgis.h:4669
Qgis::DistanceUnit::YardsBritishSears1922Truncated
@ YardsBritishSears1922Truncated
British yards (Sears 1922 truncated)
Qgis::DistanceUnit::Feet
@ Feet
Imperial feet.
Qgis::DistanceUnit::MilesUSSurvey
@ MilesUSSurvey
US Survey miles.
Qgis::DistanceUnit::LinksBritishSears1922
@ LinksBritishSears1922
British links (Sears 1922)
Qgis::DistanceUnit::YardsBritishBenoit1895A
@ YardsBritishBenoit1895A
British yards (Benoit 1895 A)
Qgis::DistanceUnit::LinksBritishBenoit1895A
@ LinksBritishBenoit1895A
British links (Benoit 1895 A)
Qgis::DistanceUnit::Centimeters
@ Centimeters
Centimeters.
Qgis::DistanceUnit::YardsIndian1975
@ YardsIndian1975
Indian yards (1975)
Qgis::DistanceUnit::FeetUSSurvey
@ FeetUSSurvey
US Survey feet.
Qgis::DistanceUnit::Millimeters
@ Millimeters
Millimeters.
Qgis::DistanceUnit::FeetBritishSears1922
@ FeetBritishSears1922
British feet (Sears 1922)
Qgis::DistanceUnit::YardsClarkes
@ YardsClarkes
Clarke's yards.
Qgis::DistanceUnit::YardsIndian
@ YardsIndian
Indian yards.
Qgis::DistanceUnit::FeetBritishBenoit1895B
@ FeetBritishBenoit1895B
British feet (Benoit 1895 B)
Qgis::DistanceUnit::Miles
@ Miles
Terrestrial miles.
Qgis::DistanceUnit::LinksUSSurvey
@ LinksUSSurvey
US Survey links.
Qgis::DistanceUnit::ChainsUSSurvey
@ ChainsUSSurvey
US Survey chains.
Qgis::DistanceUnit::FeetClarkes
@ FeetClarkes
Clarke's feet.
Qgis::DistanceUnit::Unknown
@ Unknown
Unknown distance unit.
Qgis::DistanceUnit::Yards
@ Yards
Imperial yards.
Qgis::DistanceUnit::FeetBritish1936
@ FeetBritish1936
British feet (1936)
Qgis::DistanceUnit::FeetIndian1962
@ FeetIndian1962
Indian feet (1962)
Qgis::DistanceUnit::YardsBritishSears1922
@ YardsBritishSears1922
British yards (Sears 1922)
Qgis::DistanceUnit::FeetIndian1937
@ FeetIndian1937
Indian feet (1937)
Qgis::DistanceUnit::YardsIndian1937
@ YardsIndian1937
Indian yards (1937)
Qgis::DistanceUnit::Degrees
@ Degrees
Degrees, for planar geographic CRS distance measurements.
Qgis::DistanceUnit::ChainsBritishBenoit1895B
@ ChainsBritishBenoit1895B
British chains (Benoit 1895 B)
Qgis::DistanceUnit::LinksBritishSears1922Truncated
@ LinksBritishSears1922Truncated
British links (Sears 1922 truncated)
Qgis::DistanceUnit::ChainsBritishBenoit1895A
@ ChainsBritishBenoit1895A
British chains (Benoit 1895 A)
Qgis::DistanceUnit::YardsBritishBenoit1895B
@ YardsBritishBenoit1895B
British yards (Benoit 1895 B)
Qgis::DistanceUnit::FeetBritish1865
@ FeetBritish1865
British feet (1865)
Qgis::DistanceUnit::YardsIndian1962
@ YardsIndian1962
Indian yards (1962)
Qgis::DistanceUnit::FeetBritishSears1922Truncated
@ FeetBritishSears1922Truncated
British feet (Sears 1922 truncated)
Qgis::DistanceUnit::MetersGermanLegal
@ MetersGermanLegal
German legal meter.
Qgis::DistanceUnit::LinksBritishBenoit1895B
@ LinksBritishBenoit1895B
British links (Benoit 1895 B)
Qgis::DistanceUnit::ChainsInternational
@ ChainsInternational
International chains.
Qgis::DistanceUnit::LinksInternational
@ LinksInternational
International links.
Qgis::DistanceUnit::ChainsBritishSears1922Truncated
@ ChainsBritishSears1922Truncated
British chains (Sears 1922 truncated)
Qgis::DistanceUnit::FeetIndian
@ FeetIndian
Indian (geodetic) feet.
Qgis::DistanceUnit::NauticalMiles
@ NauticalMiles
Nautical miles.
Qgis::DistanceUnit::ChainsClarkes
@ ChainsClarkes
Clarke's chains.
Qgis::DistanceUnit::LinksClarkes
@ LinksClarkes
Clarke's links.
Qgis::DistanceUnit::ChainsBritishSears1922
@ ChainsBritishSears1922
British chains (Sears 1922)
Qgis::DistanceUnit::Kilometers
@ Kilometers
Kilometers.
Qgis::DistanceUnit::FeetIndian1975
@ FeetIndian1975
Indian feet (1975)
Qgis::DistanceUnit::FeetGoldCoast
@ FeetGoldCoast
Gold Coast feet.
Qgis::DistanceUnit::FeetBritishBenoit1895A
@ FeetBritishBenoit1895A
British feet (Benoit 1895 A)
Qgis::AreaUnit
AreaUnit
Units of area.
Definition qgis.h:4746
Qgis::AreaUnit::SquareFeet
@ SquareFeet
Square feet.
Qgis::AreaUnit::SquareCentimeters
@ SquareCentimeters
Square centimeters.
Qgis::AreaUnit::SquareInches
@ SquareInches
Square inches.
Qgis::AreaUnit::SquareNauticalMiles
@ SquareNauticalMiles
Square nautical miles.
Qgis::AreaUnit::SquareMillimeters
@ SquareMillimeters
Square millimeters.
Qgis::AreaUnit::SquareYards
@ SquareYards
Square yards.
Qgis::AreaUnit::Hectares
@ Hectares
Hectares.
Qgis::AreaUnit::SquareKilometers
@ SquareKilometers
Square kilometers.
Qgis::AreaUnit::SquareMeters
@ SquareMeters
Square meters.
Qgis::AreaUnit::Unknown
@ Unknown
Unknown areal unit.
Qgis::AreaUnit::SquareDegrees
@ SquareDegrees
Square degrees, for planar geographic CRS area measurements.
Qgis::AreaUnit::SquareMiles
@ SquareMiles
Square miles.
Qgis::TemporalUnit
TemporalUnit
Temporal units.
Definition qgis.h:4815
Qgis::TemporalUnit::IrregularStep
@ IrregularStep
Special 'irregular step' time unit, used for temporal data which uses irregular, non-real-world unit ...
Qgis::TemporalUnit::Milliseconds
@ Milliseconds
Milliseconds.
Qgis::TemporalUnit::Unknown
@ Unknown
Unknown time unit.
Qgis::TemporalUnit::Centuries
@ Centuries
Centuries.
Qgis::RenderUnit
RenderUnit
Rendering size units.
Definition qgis.h:4839
Qgis::RenderUnit::Percentage
@ Percentage
Percentage of another measurement (e.g., canvas size, feature size)
Qgis::RenderUnit::Millimeters
@ Millimeters
Millimeters.
Qgis::RenderUnit::Points
@ Points
Points (e.g., for font sizes)
Qgis::RenderUnit::Unknown
@ Unknown
Mixed or unknown units.
Qgis::RenderUnit::MapUnits
@ MapUnits
Map units.
Qgis::RenderUnit::MetersInMapUnits
@ MetersInMapUnits
Meters value as Map units.
Qgis::LayoutUnitType
LayoutUnitType
Types of layout units.
Definition qgis.h:4879
Qgis::LayoutUnitType::PaperUnits
@ PaperUnits
Unit is a paper based measurement unit.
Qgis::LayoutUnitType::ScreenUnits
@ ScreenUnits
Unit is a screen based measurement unit.
Qgis::VolumeUnit
VolumeUnit
Units of volume.
Definition qgis.h:4771
Qgis::VolumeUnit::CubicMeters
@ CubicMeters
Cubic meters.
Qgis::VolumeUnit::Barrel
@ Barrel
Barrels.
Qgis::VolumeUnit::CubicYards
@ CubicYards
Cubic yards.
Qgis::VolumeUnit::CubicFeet
@ CubicFeet
Cubic feet.
Qgis::VolumeUnit::CubicDegrees
@ CubicDegrees
Cubic degrees, for planar geographic CRS volume measurements.
Qgis::VolumeUnit::CubicDecimeter
@ CubicDecimeter
Cubic decimeters.
Qgis::VolumeUnit::Unknown
@ Unknown
Unknown volume unit.
Qgis::VolumeUnit::CubicInch
@ CubicInch
Cubic inches.
Qgis::VolumeUnit::GallonUS
@ GallonUS
US Gallons.
Qgis::VolumeUnit::CubicCentimeter
@ CubicCentimeter
Cubic Centimeters.
QgsUnitTypes::decodeVolumeUnit
static Q_INVOKABLE Qgis::VolumeUnit decodeVolumeUnit(const QString &string, bool *ok=nullptr)
Decodes a volume unit from a string.
Definition qgsunittypes.cpp:2158
QgsUnitTypes::stringToDistanceUnit
static Q_INVOKABLE Qgis::DistanceUnit stringToDistanceUnit(const QString &string, bool *ok=nullptr)
Converts a translated string to a distance unit.
Definition qgsunittypes.cpp:680
QgsUnitTypes::scaledArea
static Q_INVOKABLE QgsUnitTypes::AreaValue scaledArea(double area, Qgis::AreaUnit unit, int decimals, bool keepBaseUnit=false)
Will convert an area with a given unit to an area value which is nice to display.
Definition qgsunittypes.cpp:3166
QgsUnitTypes::scaledDistance
static Q_INVOKABLE QgsUnitTypes::DistanceValue scaledDistance(double distance, Qgis::DistanceUnit unit, int decimals, bool keepBaseUnit=false)
Will convert a distance with a given unit to a distance value which is nice to display.
Definition qgsunittypes.cpp:3052
QgsUnitTypes::toString
static Q_INVOKABLE QString toString(Qgis::DistanceUnit unit)
Returns a translated string representing a distance unit.
Definition qgsunittypes.cpp:396
QgsUnitTypes::formatArea
static Q_INVOKABLE QString formatArea(double area, int decimals, Qgis::AreaUnit unit, bool keepBaseUnit=false)
Returns an area formatted as a friendly string.
Definition qgsunittypes.cpp:3382
QgsUnitTypes::fromUnitToUnitFactor
static Q_INVOKABLE double fromUnitToUnitFactor(Qgis::DistanceUnit fromUnit, Qgis::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
Definition qgsunittypes.cpp:866
QgsUnitTypes::stringToVolumeUnit
static Q_INVOKABLE Qgis::VolumeUnit stringToVolumeUnit(const QString &string, bool *ok=nullptr)
Converts a translated string to a volume unit.
Definition qgsunittypes.cpp:2255
QgsUnitTypes::formatDistance
static Q_INVOKABLE QString formatDistance(double distance, int decimals, Qgis::DistanceUnit unit, bool keepBaseUnit=false)
Returns an distance formatted as a friendly string.
Definition qgsunittypes.cpp:3362
QgsUnitTypes::toAbbreviatedString
static Q_INVOKABLE QString toAbbreviatedString(Qgis::DistanceUnit unit)
Returns a translated abbreviation representing a distance unit.
Definition qgsunittypes.cpp:586
QgsUnitTypes::unitType
static Q_INVOKABLE Qgis::DistanceUnitType unitType(Qgis::DistanceUnit unit)
Returns the type for a distance unit.
Definition qgsunittypes.cpp:73
QgsUnitTypes::decodeUnitType
static Q_INVOKABLE Qgis::UnitType decodeUnitType(const QString &string, bool *ok=nullptr)
Decodes a unit type from a string.
Definition qgsunittypes.cpp:49
QgsUnitTypes::decodeAreaUnit
static Q_INVOKABLE Qgis::AreaUnit decodeAreaUnit(const QString &string, bool *ok=nullptr)
Decodes an areal unit from a string.
Definition qgsunittypes.cpp:964
QgsUnitTypes::decodeRenderUnit
static Q_INVOKABLE Qgis::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
Definition qgsunittypes.cpp:3426
QgsUnitTypes::stringToTemporalUnit
static Q_INVOKABLE Qgis::TemporalUnit stringToTemporalUnit(const QString &string, bool *ok=nullptr)
Converts a translated string to a temporal unit.
Definition qgsunittypes.cpp:1805
QgsUnitTypes::decodeLayoutUnit
static Q_INVOKABLE Qgis::LayoutUnit decodeLayoutUnit(const QString &string, bool *ok=nullptr)
Decodes a layout unit from a string.
Definition qgsunittypes.cpp:3521
QgsUnitTypes::stringToAreaUnit
static Q_INVOKABLE Qgis::AreaUnit stringToAreaUnit(const QString &string, bool *ok=nullptr)
Converts a translated string to an areal unit.
Definition qgsunittypes.cpp:1072
QgsUnitTypes::distanceToAreaUnit
static Q_INVOKABLE Qgis::AreaUnit distanceToAreaUnit(Qgis::DistanceUnit distanceUnit)
Converts a distance unit to its corresponding area unit, e.g., meters to square meters.
Definition qgsunittypes.cpp:1548
QgsUnitTypes::decodeTemporalUnit
static Q_INVOKABLE Qgis::TemporalUnit decodeTemporalUnit(const QString &string, bool *ok=nullptr)
Decodes a temporal unit from a string.
Definition qgsunittypes.cpp:1703
QgsUnitTypes::decodeAngleUnit
static Q_INVOKABLE Qgis::AngleUnit decodeAngleUnit(const QString &string, bool *ok=nullptr)
Decodes an angular unit from a string.
Definition qgsunittypes.cpp:2733
QgsUnitTypes::areaToDistanceUnit
static Q_INVOKABLE Qgis::DistanceUnit areaToDistanceUnit(Qgis::AreaUnit areaUnit)
Converts an area unit to its corresponding distance unit, e.g., square meters to meters.
Definition qgsunittypes.cpp:1628
QgsUnitTypes::volumeToDistanceUnit
static Q_INVOKABLE Qgis::DistanceUnit volumeToDistanceUnit(Qgis::VolumeUnit volumeUnit)
Converts a volume unit to its corresponding distance unit, e.g., cubic meters to meters.
Definition qgsunittypes.cpp:2625
QgsUnitTypes::encodeUnit
static Q_INVOKABLE QString encodeUnit(Qgis::DistanceUnit unit)
Encodes a distance unit to a string.
Definition qgsunittypes.cpp:163
QgsUnitTypes::encodeUnitType
static Q_INVOKABLE QString encodeUnitType(Qgis::UnitType type)
Encodes a unit type to a string.
Definition qgsunittypes.cpp:26
QgsUnitTypes::formatAngle
static Q_INVOKABLE QString formatAngle(double angle, int decimals, Qgis::AngleUnit unit)
Returns an angle formatted as a friendly string.
Definition qgsunittypes.cpp:3003
QgsUnitTypes::distanceToVolumeUnit
static Q_INVOKABLE Qgis::VolumeUnit distanceToVolumeUnit(Qgis::DistanceUnit distanceUnit)
Converts a distance unit to its corresponding volume unit, e.g., meters to cubic meters.
Definition qgsunittypes.cpp:2542
QgsUnitTypes::decodeDistanceUnit
static Q_INVOKABLE Qgis::DistanceUnit decodeDistanceUnit(const QString &string, bool *ok=nullptr)
Decodes a distance unit from a string.
Definition qgsunittypes.cpp:325
qgsRound
double qgsRound(double number, int places)
Returns a double number, rounded (as close as possible) to the specified number of places.
Definition qgis.h:5958
qgsDoubleNear
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition qgis.h:5917
KM2_TO_M2
#define KM2_TO_M2
DEG2_TO_M3
#define DEG2_TO_M3
Definition qgsunittypes.cpp:2291
MI2_TO_M2
#define MI2_TO_M2
AC_TO_FT2
#define AC_TO_FT2
YD2_TO_M2
#define YD2_TO_M2
NM2_TO_M2
#define NM2_TO_M2
IN2_TO_M2
#define IN2_TO_M2
MM2_TO_M2
#define MM2_TO_M2
DEG2_TO_M2
#define DEG2_TO_M2
CM2_TO_M2
#define CM2_TO_M2
FT2_TO_M2
#define FT2_TO_M2
distanceUnitToMeter
constexpr double distanceUnitToMeter(Qgis::DistanceUnit unit)
Definition qgsunittypes.cpp:757
HA_TO_M2
#define HA_TO_M2
QgsUnitTypes::AreaValue
A combination of area value and unit.
Definition qgsunittypes.h:67
QgsUnitTypes::AreaValue::value
double value
The value part of the distance.
Definition qgsunittypes.h:72
QgsUnitTypes::AreaValue::unit
Qgis::AreaUnit unit
The value part of the distance.
Definition qgsunittypes.h:77
QgsUnitTypes::DistanceValue
A combination of distance value and unit.
Definition qgsunittypes.h:49
QgsUnitTypes::DistanceValue::value
double value
The value part of the distance.
Definition qgsunittypes.h:54
QgsUnitTypes::DistanceValue::unit
Qgis::DistanceUnit unit
The value part of the distance.
Definition qgsunittypes.h:59
Generated on Mon Oct 28 2024 22:06:03 for QGIS API Documentation by doxygen 1.9.8