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