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