← Back to branch summary

~ubuntu-branches/debian/sid/librecad/sid

« back to all changes in this revision

Viewing changes to src/lib/engine/rs_units.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Howard
  • Date: 2011-02-03 19:04:09 UTC
  • Revision ID: james.westby@ubuntu.com-20110203190409-202riehiqzmkydth
Tags: upstream-1.0.0~beta5
Import upstream version 1.0.0~beta5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/engine/rs_units.cpp
 
1
/****************************************************************************
 
2
**
 
3
** This file is part of the LibreCAD project, a 2D CAD program
 
4
**
 
5
** Copyright (C) 2010 R. van Twisk (librecad@rvt.dds.nl)
 
6
** Copyright (C) 2001-2003 RibbonSoft. All rights reserved.
 
7
**
 
8
**
 
9
** This program is free software; you can redistribute it and/or modify
 
10
** it under the terms of the GNU General Public License as published by 
 
11
** the Free Software Foundation; either version 2 of the License, or
 
12
** (at your option) any later version.
 
13
**
 
14
** This program is distributed in the hope that it will be useful,
 
15
** but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
** GNU General Public License for more details.
 
18
** 
 
19
** You should have received a copy of the GNU General Public License
 
20
** along with this program; if not, write to the Free Software
 
21
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
22
**
 
23
** This copyright notice MUST APPEAR in all copies of the script!  
 
24
**
 
25
**********************************************************************/
 
26
 
 
27
 
 
28
#include "rs_units.h"
 
29
 
 
30
#include <stdio.h>
 
31
#include <qobject.h>
 
32
 
 
33
#include "rs_math.h"
 
34
#include "rs_debug.h"
 
35
 
 
36
/**
 
37
 * Converts a DXF integer () to a Unit enum.
 
38
 */
 
39
RS2::Unit RS_Units::dxfint2unit(int dxfint) {
 
40
    return (RS2::Unit)dxfint;
 
41
 
 
42
    /*switch(dxfint) {
 
43
    default:
 
44
    case  0:
 
45
        return RS2::None;
 
46
    case  1:
 
47
        return RS2::Inch;
 
48
    case  2:
 
49
        return RS2::Foot;
 
50
    case  3:
 
51
        return RS2::Mile;
 
52
    case  4:
 
53
        return RS2::Millimeter;
 
54
    case  5:
 
55
        return RS2::Centimeter;
 
56
    case  6:
 
57
        return RS2::Meter;
 
58
    case  7:
 
59
        return RS2::Kilometer;
 
60
    case  8:
 
61
        return RS2::Microinch;
 
62
    case  9:
 
63
        return RS2::Mil;
 
64
    case 10:
 
65
        return RS2::Yard;
 
66
    case 11:
 
67
        return RS2::Angstrom;
 
68
    case 12:
 
69
        return RS2::Nanometer;
 
70
    case 13:
 
71
        return RS2::Micron;
 
72
    case 14:
 
73
        return RS2::Decimeter;
 
74
    case 15:
 
75
        return RS2::Decameter;
 
76
    case 16:
 
77
        return RS2::Hectometer;
 
78
    case 17:
 
79
        return RS2::Gigameter;
 
80
    case 18:
 
81
        return RS2::Astro;
 
82
    case 19:
 
83
        return RS2::Lightyear;
 
84
    case 20:
 
85
        return RS2::Parsec;
 
86
}*/
 
87
}
 
88
 
 
89
 
 
90
/**
 
91
 * @return a short string representing the given unit (e.g. "mm")
 
92
 */
 
93
RS_String RS_Units::unitToSign(RS2::Unit u) {
 
94
    RS_String ret = "";
 
95
 
 
96
    switch (u) {
 
97
    case RS2::None:
 
98
        ret = "";
 
99
        break;
 
100
    case RS2::Inch:
 
101
        ret = "\"";
 
102
        break;
 
103
    case RS2::Foot:
 
104
        ret = "'";
 
105
        break;
 
106
    case RS2::Mile:
 
107
        ret = "mi";
 
108
        break;
 
109
    case RS2::Millimeter:
 
110
        ret = "mm";
 
111
        break;
 
112
    case RS2::Centimeter:
 
113
        ret = "cm";
 
114
        break;
 
115
    case RS2::Meter:
 
116
        ret = "m";
 
117
        break;
 
118
    case RS2::Kilometer:
 
119
        ret = "km";
 
120
        break;
 
121
    case RS2::Microinch:
 
122
        ret = "µ\"";
 
123
        break;
 
124
    case RS2::Mil:
 
125
        ret = "mil";
 
126
        break;
 
127
    case RS2::Yard:
 
128
        ret = "yd";
 
129
        break;
 
130
    case RS2::Angstrom:
 
131
        ret = "A";
 
132
        break;
 
133
    case RS2::Nanometer:
 
134
        ret = "nm";
 
135
        break;
 
136
    case RS2::Micron:
 
137
        ret = "µm";
 
138
        break;
 
139
    case RS2::Decimeter:
 
140
        ret = "dm";
 
141
        break;
 
142
    case RS2::Decameter:
 
143
        ret = "dam";
 
144
        break;
 
145
    case RS2::Hectometer:
 
146
        ret = "hm";
 
147
        break;
 
148
    case RS2::Gigameter:
 
149
        ret = "Gm";
 
150
        break;
 
151
    case RS2::Astro:
 
152
        ret = "astro";
 
153
        break;
 
154
    case RS2::Lightyear:
 
155
        ret = "ly";
 
156
        break;
 
157
    case RS2::Parsec:
 
158
        ret = "pc";
 
159
        break;
 
160
 
 
161
    default:
 
162
        ret = "";
 
163
        break;
 
164
    }
 
165
 
 
166
    return ret;
 
167
}
 
168
 
 
169
 
 
170
 
 
171
/**
 
172
 * @return a string representing the given unit (e.g. "Millimeter").
 
173
 *      translated if @a t is true (the default).
 
174
 */
 
175
RS_String RS_Units::unitToString(RS2::Unit u, bool t) {
 
176
    RS_String ret = "";
 
177
 
 
178
    switch (u) {
 
179
    case RS2::None:
 
180
        ret = t ? QObject::tr("None") : RS_String("None");
 
181
        break;
 
182
    case RS2::Inch:
 
183
        ret = t ? QObject::tr("Inch") : RS_String("Inch");
 
184
        break;
 
185
    case RS2::Foot:
 
186
        ret = t ? QObject::tr("Foot") : RS_String("Foot");
 
187
        break;
 
188
    case RS2::Mile:
 
189
        ret = t ? QObject::tr("Mile") : RS_String("Mile");
 
190
        break;
 
191
    case RS2::Millimeter:
 
192
        ret = t ? QObject::tr("Millimeter") : RS_String("Millimeter");
 
193
        break;
 
194
    case RS2::Centimeter:
 
195
        ret = t ? QObject::tr("Centimeter") : RS_String("Centimeter");
 
196
        break;
 
197
    case RS2::Meter:
 
198
        ret = t ? QObject::tr("Meter") : RS_String("Meter");
 
199
        break;
 
200
    case RS2::Kilometer:
 
201
        ret = t ? QObject::tr("Kilometer") : RS_String("Kilometer");
 
202
        break;
 
203
    case RS2::Microinch:
 
204
        ret = t ? QObject::tr("Microinch") : RS_String("Microinch");
 
205
        break;
 
206
    case RS2::Mil:
 
207
        ret = t ? QObject::tr("Mil") : RS_String("Mil");
 
208
        break;
 
209
    case RS2::Yard:
 
210
        ret = t ? QObject::tr("Yard") : RS_String("Yard");
 
211
        break;
 
212
    case RS2::Angstrom:
 
213
        ret = t ? QObject::tr("Angstrom") : RS_String("Angstrom");
 
214
        break;
 
215
    case RS2::Nanometer:
 
216
        ret = t ? QObject::tr("Nanometer") : RS_String("Nanometer");
 
217
        break;
 
218
    case RS2::Micron:
 
219
        ret = t ? QObject::tr("Micron") : RS_String("Micron");
 
220
        break;
 
221
    case RS2::Decimeter:
 
222
        ret = t ? QObject::tr("Decimeter") : RS_String("Decimeter");
 
223
        break;
 
224
    case RS2::Decameter:
 
225
        ret = t ? QObject::tr("Decameter") : RS_String("Decameter");
 
226
        break;
 
227
    case RS2::Hectometer:
 
228
        ret = t ? QObject::tr("Hectometer") : RS_String("Hectometer");
 
229
        break;
 
230
    case RS2::Gigameter:
 
231
        ret = t ? QObject::tr("Gigameter") : RS_String("Gigameter");
 
232
        break;
 
233
    case RS2::Astro:
 
234
        ret = t ? QObject::tr("Astro") : RS_String("Astro");
 
235
        break;
 
236
    case RS2::Lightyear:
 
237
        ret = t ? QObject::tr("Lightyear") : RS_String("Lightyear");
 
238
        break;
 
239
    case RS2::Parsec:
 
240
        ret = t ? QObject::tr("Parsec") : RS_String("Parsec");
 
241
        break;
 
242
 
 
243
    default:
 
244
        ret = "";
 
245
        break;
 
246
    }
 
247
 
 
248
    return ret;
 
249
}
 
250
 
 
251
 
 
252
 
 
253
/**
 
254
 * Converts a string into a unit enum.
 
255
 */
 
256
RS2::Unit RS_Units::stringToUnit(const RS_String& u) {
 
257
    RS2::Unit ret = RS2::None;
 
258
 
 
259
    if (u=="None") {
 
260
        ret = RS2::None;
 
261
    } else if (u==QObject::tr("Inch")) {
 
262
        ret = RS2::Inch;
 
263
    } else if (u==QObject::tr("Foot")) {
 
264
        ret = RS2::Foot;
 
265
    } else if (u==QObject::tr("Mile")) {
 
266
        ret = RS2::Mile;
 
267
    } else if (u==QObject::tr("Millimeter")) {
 
268
        ret = RS2::Millimeter;
 
269
    } else if (u==QObject::tr("Centimeter")) {
 
270
        ret = RS2::Centimeter;
 
271
    } else if (u==QObject::tr("Meter")) {
 
272
        ret = RS2::Meter;
 
273
    } else if (u==QObject::tr("Kilometer")) {
 
274
        ret = RS2::Kilometer;
 
275
    } else if (u==QObject::tr("Microinch")) {
 
276
        ret = RS2::Microinch;
 
277
    } else if (u==QObject::tr("Mil")) {
 
278
        ret = RS2::Mil;
 
279
    } else if (u==QObject::tr("Yard")) {
 
280
        ret = RS2::Yard;
 
281
    } else if (u==QObject::tr("Angstrom")) {
 
282
        ret = RS2::Angstrom;
 
283
    } else if (u==QObject::tr("Nanometer")) {
 
284
        ret = RS2::Nanometer;
 
285
    } else if (u==QObject::tr("Micron")) {
 
286
        ret = RS2::Micron;
 
287
    } else if (u==QObject::tr("Decimeter")) {
 
288
        ret = RS2::Decimeter;
 
289
    } else if (u==QObject::tr("Decameter")) {
 
290
        ret = RS2::Decameter;
 
291
    } else if (u==QObject::tr("Hectometer")) {
 
292
        ret = RS2::Hectometer;
 
293
    } else if (u==QObject::tr("Gigameter")) {
 
294
        ret = RS2::Gigameter;
 
295
    } else if (u==QObject::tr("Astro")) {
 
296
        ret = RS2::Astro;
 
297
    } else if (u==QObject::tr("Lightyear")) {
 
298
        ret = RS2::Lightyear;
 
299
    } else if (u==QObject::tr("Parsec")) {
 
300
        ret = RS2::Parsec;
 
301
    }
 
302
 
 
303
    return ret;
 
304
}
 
305
 
 
306
 
 
307
 
 
308
 
 
309
/**
 
310
 * @return true: the unit is metric, false: the unit is imperial.
 
311
 */
 
312
bool RS_Units::isMetric(RS2::Unit u) {
 
313
    if (u==RS2::Millimeter ||
 
314
            u==RS2::Centimeter ||
 
315
            u==RS2::Meter ||
 
316
            u==RS2::Kilometer ||
 
317
            u==RS2::Angstrom ||
 
318
            u==RS2::Nanometer ||
 
319
            u==RS2::Micron ||
 
320
            u==RS2::Decimeter ||
 
321
            u==RS2::Decameter ||
 
322
            u==RS2::Hectometer ||
 
323
            u==RS2::Gigameter ||
 
324
            u==RS2::Astro ||
 
325
            u==RS2::Lightyear ||
 
326
            u==RS2::Parsec) {
 
327
 
 
328
        return true;
 
329
    } else {
 
330
        return false;
 
331
    }
 
332
}
 
333
 
 
334
 
 
335
 
 
336
/**
 
337
 * @return factor to convert the given unit to Millimeters.
 
338
 */
 
339
double RS_Units::getFactorToMM(RS2::Unit u) {
 
340
    double ret = 1.0;
 
341
 
 
342
    switch (u) {
 
343
    case RS2::None:
 
344
        ret = 1.0;
 
345
        break;
 
346
    case RS2::Inch:
 
347
        ret = 25.4;
 
348
        break;
 
349
    case RS2::Foot:
 
350
        ret = 304.8;
 
351
        break;
 
352
    case RS2::Mile:
 
353
        ret = 1609344;
 
354
        break;
 
355
    case RS2::Millimeter:
 
356
        ret = 1.0;
 
357
        break;
 
358
    case RS2::Centimeter:
 
359
        ret = 10;
 
360
        break;
 
361
    case RS2::Meter:
 
362
        ret = 1000;
 
363
        break;
 
364
    case RS2::Kilometer:
 
365
        ret = 1000000;
 
366
        break;
 
367
    case RS2::Microinch:
 
368
        ret = 0.0000254;
 
369
        break;
 
370
    case RS2::Mil:
 
371
        ret = 0.0254;
 
372
        break;
 
373
    case RS2::Yard:
 
374
        ret = 914.4;
 
375
        break;
 
376
    case RS2::Angstrom:
 
377
        ret = 0.0000001;
 
378
        break;
 
379
    case RS2::Nanometer:
 
380
        ret = 0.000001;
 
381
        break;
 
382
    case RS2::Micron:
 
383
        ret = 0.001;
 
384
        break;
 
385
    case RS2::Decimeter:
 
386
        ret = 100.0;
 
387
        break;
 
388
    case RS2::Decameter:
 
389
        ret = 10000.0;
 
390
        break;
 
391
    case RS2::Hectometer:
 
392
        ret = 100000.0;
 
393
        break;
 
394
    case RS2::Gigameter:
 
395
        ret = 1000000000.0;
 
396
        break;
 
397
    case RS2::Astro:
 
398
        ret = 149600000000000.0;
 
399
        break;
 
400
    case RS2::Lightyear:
 
401
        ret = 9460731798000000000.0;
 
402
        break;
 
403
    case RS2::Parsec:
 
404
        ret = 30857000000000000000.0;
 
405
        break;
 
406
    default:
 
407
        ret = 1.0;
 
408
        break;
 
409
    }
 
410
 
 
411
    return ret;
 
412
}
 
413
 
 
414
 
 
415
/**
 
416
 * Converts the given value 'val' from unit 'src' to unit 'dest'.
 
417
 */
 
418
double RS_Units::convert(double val, RS2::Unit src, RS2::Unit dest) {
 
419
    if (getFactorToMM(dest)>0.0) {
 
420
        return (val*getFactorToMM(src))/getFactorToMM(dest);
 
421
    } else {
 
422
        RS_DEBUG->print(RS_Debug::D_WARNING,
 
423
                        "RS_Units::convert: invalid factor");
 
424
        return val;
 
425
    }
 
426
}
 
427
 
 
428
 
 
429
 
 
430
/**
 
431
 * Converts the given vector 'val' from unit 'src' to unit 'dest'.
 
432
 */
 
433
RS_Vector RS_Units::convert(const RS_Vector val, RS2::Unit src, RS2::Unit dest) {
 
434
    return RS_Vector(convert(val.x, src, dest),
 
435
                     convert(val.y, src, dest),
 
436
                     convert(val.z, src, dest));
 
437
}
 
438
 
 
439
 
 
440
 
 
441
/**
 
442
 * Formats the given length in the given format.
 
443
 *
 
444
 * @param length The length in the current unit of the drawing.
 
445
 * @param format Format of the string.
 
446
 * @param prec Precisision of the value (e.g. 0.001 or 1/128 = 0.0078125)
 
447
 & @param showUnit Append unit to the value.
 
448
 */
 
449
RS_String RS_Units::formatLinear(double length, RS2::Unit unit,
 
450
                                 RS2::LinearFormat format,
 
451
                                 int prec, bool showUnit) {
 
452
    RS_String ret;
 
453
 
 
454
    // unit appended to value (e.g. 'mm'):
 
455
    /*RS_String unitString = "";
 
456
    if (showUnit) {
 
457
        unitString = unitToSign(unit);
 
458
}*/
 
459
 
 
460
    // barbarian display: show as fraction:
 
461
    switch (format) {
 
462
    case RS2::Scientific:
 
463
        ret = formatScientific(length, unit, prec, showUnit);
 
464
        break;
 
465
 
 
466
    case RS2::Decimal:
 
467
        ret = formatDecimal(length, unit, prec, showUnit);
 
468
        break;
 
469
 
 
470
    case RS2::Engineering:
 
471
        ret = formatEngineering(length, unit, prec, showUnit);
 
472
        break;
 
473
 
 
474
    case RS2::Architectural:
 
475
        ret = formatArchitectural(length, unit, prec, showUnit);
 
476
        break;
 
477
 
 
478
    case RS2::Fractional:
 
479
        ret = formatFractional(length, unit, prec, showUnit);
 
480
        break;
 
481
 
 
482
    default:
 
483
        RS_DEBUG->print(RS_Debug::D_WARNING,
 
484
                        "RS_Units::formatLinear: Unknown format");
 
485
        ret = "";
 
486
        break;
 
487
    }
 
488
 
 
489
    return ret;
 
490
}
 
491
 
 
492
 
 
493
 
 
494
/**
 
495
 * Formats the given length in scientific format (e.g. 2.5E7).
 
496
 *
 
497
 * @param length The length in the current unit of the drawing.
 
498
 * @param prec Precisision of the value (e.g. 0.001 or 1/128 = 0.0078125)
 
499
 & @param showUnit Append unit to the value.
 
500
 */
 
501
RS_String RS_Units::formatScientific(double length, RS2::Unit unit,
 
502
                                     int prec, bool showUnit) {
 
503
 
 
504
    RS_String ret;
 
505
 
 
506
    // unit appended to value (e.g. 'mm'):
 
507
    RS_String unitString = "";
 
508
    if (showUnit) {
 
509
        unitString = unitToSign(unit);
 
510
    }
 
511
 
 
512
    char format[128];
 
513
    sprintf(format, "%%.%dE%%s", prec);
 
514
    ret.sprintf(format, length, (const char*)unitString.local8Bit());
 
515
 
 
516
    return ret;
 
517
}
 
518
 
 
519
 
 
520
 
 
521
/**
 
522
 * Formats the given length in decimal (normal) format (e.g. 2.5).
 
523
 *
 
524
 * @param length The length in the current unit of the drawing.
 
525
 * @param prec Precisision of the value (e.g. 0.001)
 
526
 & @param showUnit Append unit to the value.
 
527
 */
 
528
RS_String RS_Units::formatDecimal(double length, RS2::Unit unit,
 
529
                                  int prec, bool showUnit) {
 
530
 
 
531
    RS_String ret;
 
532
 
 
533
    // unit appended to value (e.g. 'mm'):
 
534
    RS_String unitString = "";
 
535
    if (showUnit) {
 
536
        unitString = unitToSign(unit);
 
537
    }
 
538
 
 
539
    ret = RS_Math::doubleToString(length, prec);
 
540
    if(showUnit) {
 
541
        ret+=unitString;
 
542
    }
 
543
 
 
544
    return ret;
 
545
}
 
546
 
 
547
 
 
548
 
 
549
/**
 
550
 * Formats the given length in engineering format (e.g. 5' 4.5").
 
551
 *
 
552
 * @param length The length in the current unit of the drawing.
 
553
 * @param prec Precisision of the value (e.g. 0.001 or 1/128 = 0.0078125)
 
554
 & @param showUnit Append unit to the value.
 
555
 */
 
556
RS_String RS_Units::formatEngineering(double length, RS2::Unit /*unit*/,
 
557
                                      int prec, bool /*showUnit*/) {
 
558
    RS_String ret;
 
559
 
 
560
    bool sign = (length<0.0);
 
561
    int feet = (int)floor(fabs(length)/12);
 
562
    double inches = fabs(length) - feet*12;
 
563
 
 
564
    RS_String sInches = RS_Math::doubleToString(inches, prec);
 
565
 
 
566
    if (sInches=="12") {
 
567
        feet++;
 
568
        sInches="0";
 
569
    }
 
570
 
 
571
    if (feet!=0) {
 
572
        ret.sprintf("%d'-%s\"", feet, (const char*)sInches.local8Bit());
 
573
    } else {
 
574
        ret.sprintf("%s\"", (const char*)sInches.local8Bit());
 
575
    }
 
576
 
 
577
    if (sign) {
 
578
        ret = "-" + ret;
 
579
    }
 
580
 
 
581
    return ret;
 
582
}
 
583
 
 
584
 
 
585
 
 
586
/**
 
587
 * Formats the given length in architectural format (e.g. 5' 4 1/2").
 
588
 *
 
589
 * @param length The length in the current unit of the drawing.
 
590
 * @param prec Precisision of the value (e.g. 0.001 or 1/128 = 0.0078125)
 
591
 & @param showUnit Append unit to the value.
 
592
 */
 
593
RS_String RS_Units::formatArchitectural(double length, RS2::Unit /*unit*/,
 
594
                                        int prec, bool showUnit) {
 
595
    RS_String ret;
 
596
    bool neg = (length<0.0);
 
597
 
 
598
    int feet = (int)floor(fabs(length)/12);
 
599
    double inches = fabs(length) - feet*12;
 
600
 
 
601
    RS_String sInches = formatFractional(inches, RS2::Inch, prec, showUnit);
 
602
 
 
603
    if (sInches=="12") {
 
604
        feet++;
 
605
        sInches = "0";
 
606
    }
 
607
 
 
608
    if (neg) {
 
609
        ret.sprintf("-%d'-%s\"", feet, (const char*)sInches.local8Bit());
 
610
    } else {
 
611
        ret.sprintf("%d'-%s\"", feet, (const char*)sInches.local8Bit());
 
612
    }
 
613
 
 
614
    return ret;
 
615
}
 
616
 
 
617
 
 
618
 
 
619
/**
 
620
 * Formats the given length in fractional (barbarian) format (e.g. 5' 3 1/64").
 
621
 *
 
622
 * @param length The length in the current unit of the drawing.
 
623
 * @param unit Should be inches.
 
624
 * @param prec Precisision of the value (e.g. 0.001 or 1/128 = 0.0078125)
 
625
 & @param showUnit Append unit to the value.
 
626
 */
 
627
RS_String RS_Units::formatFractional(double length, RS2::Unit /*unit*/,
 
628
                                     int prec, bool /*showUnit*/) {
 
629
 
 
630
    RS_String ret;
 
631
 
 
632
    int num;            // number of complete inches (num' 7/128")
 
633
    int nominator;      // number of fractions (nominator/128)
 
634
    int denominator;    // (4/denominator)
 
635
 
 
636
    // sign:
 
637
    RS_String neg = "";
 
638
    if(length < 0) {
 
639
        neg = "-";
 
640
        length = fabs(length);
 
641
    }
 
642
 
 
643
    num = (int)floor(length);
 
644
 
 
645
    denominator = (int)RS_Math::pow(2, prec);
 
646
    nominator = RS_Math::round((length-num)*denominator);
 
647
 
 
648
    // fraction rounds up to 1:
 
649
    if (nominator==denominator) {
 
650
        nominator=0;
 
651
        denominator=0;
 
652
        ++num;
 
653
    }
 
654
 
 
655
    // Simplify the fraction
 
656
    if (nominator!=0 && denominator!=0) {
 
657
        int gcd = RS_Math::findGCD(nominator, denominator);
 
658
        if (gcd!=0) {
 
659
            nominator = nominator / gcd;
 
660
            denominator = denominator / gcd;
 
661
        } else {
 
662
            RS_DEBUG->print(RS_Debug::D_WARNING,
 
663
                                "RS_Units::formatFractional: invalid gcd");
 
664
            nominator = 0;
 
665
            denominator = 0;
 
666
        }
 
667
    }
 
668
 
 
669
    if( num!=0 && nominator!=0 ) {
 
670
        ret.sprintf("%s%d %d/%d",
 
671
                    (const char*)neg.local8Bit(), num,
 
672
                    nominator, denominator);
 
673
    } else if(nominator!=0) {
 
674
        ret.sprintf("%s%d/%d",
 
675
                    (const char*)neg.local8Bit(),
 
676
                    nominator, denominator);
 
677
    } else if(num!=0) {
 
678
        ret.sprintf("%s%d",
 
679
                    (const char*)neg.local8Bit(),
 
680
                    num);
 
681
    } else {
 
682
        ret.sprintf("0");
 
683
    }
 
684
 
 
685
    return ret;
 
686
}
 
687
 
 
688
 
 
689
 
 
690
 
 
691
 
 
692
/**
 
693
 * Formats the given angle with the given format.
 
694
 *
 
695
 * @param angle The angle (always in rad).
 
696
 * @param format Format of the string.
 
697
 * @param prec Precisision of the value (e.g. 0.001 or 1/128 = 0.0078125)
 
698
 *
 
699
 * @ret String with the formatted angle.
 
700
 */
 
701
RS_String RS_Units::formatAngle(double angle, RS2::AngleFormat format,
 
702
                                int prec) {
 
703
 
 
704
    RS_String ret;
 
705
    double value;
 
706
 
 
707
    switch (format) {
 
708
    case RS2::DegreesDecimal:
 
709
    case RS2::DegreesMinutesSeconds:
 
710
        value = RS_Math::rad2deg(angle);
 
711
        break;
 
712
    case RS2::Radians:
 
713
        value = angle;
 
714
        break;
 
715
    case RS2::Gradians:
 
716
        value = RS_Math::rad2gra(angle);
 
717
        break;
 
718
    default:
 
719
        RS_DEBUG->print(RS_Debug::D_WARNING,
 
720
                        "RS_Units::formatAngle: Unknown Angle Unit");
 
721
        return "";
 
722
        break;
 
723
    }
 
724
 
 
725
    switch (format) {
 
726
    case RS2::DegreesDecimal:
 
727
    case RS2::Radians:
 
728
    case RS2::Gradians:
 
729
        ret = RS_Math::doubleToString(value, prec);
 
730
        if (format==RS2::DegreesDecimal)
 
731
            ret+=QChar(0xB0);
 
732
        if (format==RS2::Radians)
 
733
            ret+="r";
 
734
        if (format==RS2::Gradians)
 
735
            ret+="g";
 
736
        break;
 
737
 
 
738
    case RS2::DegreesMinutesSeconds: {
 
739
            int vDegrees, vMinutes;
 
740
            double vSeconds;
 
741
            RS_String degrees, minutes, seconds;
 
742
 
 
743
            vDegrees = (int)floor(value);
 
744
            vMinutes = (int)floor((value - vDegrees) * 60.0);
 
745
            vSeconds = (value - vDegrees - (vMinutes/60.0)) * 3600.0;
 
746
 
 
747
            seconds = RS_Math::doubleToString(vSeconds, (prec>1 ? prec-2 : 0));
 
748
 
 
749
            if(seconds=="60") {
 
750
                seconds="0";
 
751
                ++vMinutes;
 
752
                if(vMinutes==60) {
 
753
                    vMinutes=0;
 
754
                    ++vDegrees;
 
755
                }
 
756
            }
 
757
 
 
758
            if (prec==0 && vMinutes>=30.0) {
 
759
                vDegrees++;
 
760
            } else if (prec==1 && vSeconds>=30.0) {
 
761
                vMinutes++;
 
762
            }
 
763
 
 
764
            degrees.setNum(vDegrees);
 
765
            minutes.setNum(vMinutes);
 
766
 
 
767
            switch (prec) {
 
768
            case 0:
 
769
                ret = degrees + QChar(0xB0);
 
770
                break;
 
771
            case 1:
 
772
                ret = degrees + QChar(0xB0) + " " + minutes + "'";
 
773
                break;
 
774
            default:
 
775
                ret = degrees + QChar(0xB0) + " " + minutes + "' "
 
776
                      + seconds + "\"";
 
777
                break;
 
778
            }
 
779
        }
 
780
        break;
 
781
 
 
782
    default:
 
783
        break;
 
784
    }
 
785
 
 
786
    return ret;
 
787
}
 
788
 
 
789
 
 
790
 
 
791
/**
 
792
 * @return Size of the given paper format.
 
793
 */
 
794
RS_Vector RS_Units::paperFormatToSize(RS2::PaperFormat p) {
 
795
    RS_Vector ret(false);
 
796
 
 
797
    switch (p) {
 
798
    case RS2::Custom:
 
799
        ret = RS_Vector(0.0, 0.0);
 
800
        break;
 
801
    case RS2::Letter:
 
802
        ret = RS_Vector(215.9, 279.4);
 
803
        break;
 
804
    case RS2::Legal:
 
805
        ret = RS_Vector(215.9, 355.6);
 
806
        break;
 
807
    case RS2::Executive:
 
808
        ret = RS_Vector(190.5, 254.0);
 
809
        break;
 
810
    case RS2::A0:
 
811
        ret = RS_Vector(841.0, 1189.0);
 
812
        break;
 
813
    case RS2::A1:
 
814
        ret = RS_Vector(594.0, 841.0);
 
815
        break;
 
816
    case RS2::A2:
 
817
        ret = RS_Vector(420.0, 594.0);
 
818
        break;
 
819
    case RS2::A3:
 
820
        ret = RS_Vector(297.0, 420.0);
 
821
        break;
 
822
    case RS2::A4:
 
823
        ret = RS_Vector(210.0, 297.0);
 
824
        break;
 
825
    case RS2::A5:
 
826
        ret = RS_Vector(148.0, 210.0);
 
827
        break;
 
828
    case RS2::A6:
 
829
        ret = RS_Vector(105.0, 148.0);
 
830
        break;
 
831
    case RS2::A7:
 
832
        ret = RS_Vector(74.0, 105.0);
 
833
        break;
 
834
    case RS2::A8:
 
835
        ret = RS_Vector(52.0, 74.0);
 
836
        break;
 
837
    case RS2::A9:
 
838
        ret = RS_Vector(37.0, 52.0);
 
839
        break;
 
840
        /*case RS2::A10:
 
841
            ret = RS_Vector(26.0, 37.0);
 
842
            break;*/
 
843
    case RS2::B0:
 
844
        ret = RS_Vector(1000.0, 1414.0);
 
845
        break;
 
846
    case RS2::B1:
 
847
        ret = RS_Vector(707.0, 1000.0);
 
848
        break;
 
849
    case RS2::B2:
 
850
        ret = RS_Vector(500.0, 707.0);
 
851
        break;
 
852
    case RS2::B3:
 
853
        ret = RS_Vector(353.0, 500.0);
 
854
        break;
 
855
    case RS2::B4:
 
856
        ret = RS_Vector(250.0, 353.0);
 
857
        break;
 
858
    case RS2::B5:
 
859
        ret = RS_Vector(176.0, 250.0);
 
860
        break;
 
861
    case RS2::B6:
 
862
        ret = RS_Vector(125.0, 176.0);
 
863
        break;
 
864
    case RS2::B7:
 
865
        ret = RS_Vector(88.0, 125.0);
 
866
        break;
 
867
    case RS2::B8:
 
868
        ret = RS_Vector(62.0, 88.0);
 
869
        break;
 
870
    case RS2::B9:
 
871
        ret = RS_Vector(44.0, 62.0);
 
872
        break;
 
873
    case RS2::B10:
 
874
        ret = RS_Vector(31.0, 44.0);
 
875
        break;
 
876
        /*
 
877
          case RS2::C0:
 
878
              ret = RS_Vector(917.0, 1297.0);
 
879
              break;
 
880
          case RS2::C1:
 
881
              ret = RS_Vector(648.0, 917.0);
 
882
              break;
 
883
          case RS2::C2:
 
884
              ret = RS_Vector(458.0, 648.0);
 
885
              break;
 
886
          case RS2::C3:
 
887
              ret = RS_Vector(324.0, 458.0);
 
888
              break;
 
889
          case RS2::C4:
 
890
              ret = RS_Vector(229.0, 324.0);
 
891
              break;
 
892
          case RS2::C5:
 
893
              ret = RS_Vector(162.0, 229.0);
 
894
              break;
 
895
          case RS2::C6:
 
896
              ret = RS_Vector(114.0, 162.0);
 
897
              break;
 
898
          case RS2::C7:
 
899
              ret = RS_Vector(81.0, 114.0);
 
900
              break;
 
901
          case RS2::C8:
 
902
              ret = RS_Vector(57.0, 81.0);
 
903
              break;
 
904
          case RS2::C9:
 
905
              ret = RS_Vector(40.0, 57.0);
 
906
              break;
 
907
          case RS2::C10:
 
908
              ret = RS_Vector(28.0, 40.0);
 
909
              break;
 
910
        */
 
911
    case RS2::C5E:
 
912
        ret = RS_Vector(163.0, 229.0);
 
913
        break;
 
914
    case RS2::Comm10E:
 
915
        ret = RS_Vector(105.0, 241.0);
 
916
        break;
 
917
    case RS2::DLE:
 
918
        ret = RS_Vector(110.0, 220.0);
 
919
        break;
 
920
    case RS2::Folio:
 
921
        ret = RS_Vector(210.0, 330.0);
 
922
        break;
 
923
    //case RS2::Ledger:
 
924
    //    ret = RS_Vector(432.0, 279.0);
 
925
    //    break;
 
926
    case RS2::Tabloid:
 
927
        ret = RS_Vector(279.0, 432.0);
 
928
        break;
 
929
    case RS2::NPageSize:
 
930
        ret = RS_Vector(0.0, 0.0);
 
931
        break;
 
932
    default:
 
933
        break;
 
934
    }
 
935
 
 
936
    return ret;
 
937
}
 
938
 
 
939
 
 
940
 
 
941
/**
 
942
 * Gets the paper format which matches the given size. If no
 
943
 * format matches, RS2::Custom is returned.
 
944
 */
 
945
RS2::PaperFormat RS_Units::paperSizeToFormat(const RS_Vector s) {
 
946
    RS_Vector ts1;
 
947
    RS_Vector ts2;
 
948
 
 
949
    for (int i=(int)RS2::Custom; i<=(int)RS2::NPageSize; ++i) {
 
950
        ts1 = RS_Units::paperFormatToSize((RS2::PaperFormat)i);
 
951
        ts2 = RS_Vector(ts1.y, ts1.x);
 
952
 
 
953
        if (ts1.distanceTo(s)<1.0e-4 || ts2.distanceTo(s)<1.0e-4) {
 
954
            return (RS2::PaperFormat)i;
 
955
        }
 
956
    }
 
957
 
 
958
    return RS2::Custom;
 
959
}
 
960
 
 
961
 
 
962
 
 
963
/**
 
964
 * Converts a paper format to a string (e.g. for a combobox).
 
965
 */
 
966
RS_String RS_Units::paperFormatToString(RS2::PaperFormat p) {
 
967
    RS_String ret = "";
 
968
 
 
969
    switch (p) {
 
970
    case RS2::Custom:
 
971
        ret = "Custom";
 
972
        break;
 
973
    case RS2::Letter:
 
974
        ret = "Letter";
 
975
        break;
 
976
    case RS2::Legal:
 
977
        ret = "Legal";
 
978
        break;
 
979
    case RS2::Executive:
 
980
        ret = "Executive";
 
981
        break;
 
982
    case RS2::A0:
 
983
        ret = "A0";
 
984
        break;
 
985
    case RS2::A1:
 
986
        ret = "A1";
 
987
        break;
 
988
    case RS2::A2:
 
989
        ret = "A2";
 
990
        break;
 
991
    case RS2::A3:
 
992
        ret = "A3";
 
993
        break;
 
994
    case RS2::A4:
 
995
        ret = "A4";
 
996
        break;
 
997
    case RS2::A5:
 
998
        ret = "A5";
 
999
        break;
 
1000
    case RS2::A6:
 
1001
        ret = "A6";
 
1002
        break;
 
1003
    case RS2::A7:
 
1004
        ret = "A7";
 
1005
        break;
 
1006
    case RS2::A8:
 
1007
        ret = "A8";
 
1008
        break;
 
1009
    case RS2::A9:
 
1010
        ret = "A9";
 
1011
        break;
 
1012
    case RS2::B0:
 
1013
        ret = "B0";
 
1014
        break;
 
1015
    case RS2::B1:
 
1016
        ret = "B1";
 
1017
        break;
 
1018
    case RS2::B2:
 
1019
        ret = "B2";
 
1020
        break;
 
1021
    case RS2::B3:
 
1022
        ret = "B3";
 
1023
        break;
 
1024
    case RS2::B4:
 
1025
        ret = "B4";
 
1026
        break;
 
1027
    case RS2::B5:
 
1028
        ret = "B5";
 
1029
        break;
 
1030
    case RS2::B6:
 
1031
        ret = "B6";
 
1032
        break;
 
1033
    case RS2::B7:
 
1034
        ret = "B7";
 
1035
        break;
 
1036
    case RS2::B8:
 
1037
        ret = "B8";
 
1038
        break;
 
1039
    case RS2::B9:
 
1040
        ret = "B9";
 
1041
        break;
 
1042
    case RS2::B10:
 
1043
        ret = "B10";
 
1044
        break;
 
1045
        /*
 
1046
           case RS2::C0:
 
1047
               ret = "C0";
 
1048
               break;
 
1049
           case RS2::C1:
 
1050
               ret = "C1";
 
1051
               break;
 
1052
           case RS2::C2:
 
1053
               ret = "C2";
 
1054
               break;
 
1055
           case RS2::C3:
 
1056
               ret = "C3";
 
1057
               break;
 
1058
           case RS2::C4:
 
1059
               ret = "C4";
 
1060
               break;
 
1061
           case RS2::C5:
 
1062
               ret = "C5";
 
1063
               break;
 
1064
           case RS2::C6:
 
1065
               ret = "C6";
 
1066
               break;
 
1067
           case RS2::C7:
 
1068
               ret = "C7";
 
1069
               break;
 
1070
           case RS2::C8:
 
1071
               ret = "C8";
 
1072
               break;
 
1073
           case RS2::C9:
 
1074
               ret = "C9";
 
1075
               break;
 
1076
           case RS2::C10:
 
1077
               ret = "C10";
 
1078
               break;
 
1079
        */
 
1080
    case RS2::C5E:
 
1081
        ret = "C5E";
 
1082
        break;
 
1083
    case RS2::Comm10E:
 
1084
        ret = "Comm10E";
 
1085
        break;
 
1086
    case RS2::DLE:
 
1087
        ret = "DLE";
 
1088
        break;
 
1089
    case RS2::Folio:
 
1090
        ret = "Folio";
 
1091
        break;
 
1092
    //case RS2::Ledger:
 
1093
    //    ret = "Ledger";
 
1094
    //    break;
 
1095
    case RS2::Tabloid:
 
1096
        ret = "Tabloid";
 
1097
        break;
 
1098
    case RS2::NPageSize:
 
1099
        ret = "NPageSize";
 
1100
        break;
 
1101
    default:
 
1102
        break;
 
1103
    }
 
1104
 
 
1105
    return ret;
 
1106
}
 
1107
 
 
1108
 
 
1109
 
 
1110
/**
 
1111
 * Converts a string to a paper format.
 
1112
 */
 
1113
RS2::PaperFormat RS_Units::stringToPaperFormat(const RS_String& p) {
 
1114
    RS_String ls = p.lower();
 
1115
    RS2::PaperFormat ret = RS2::Custom;
 
1116
 
 
1117
    if (p=="custom") {
 
1118
        ret = RS2::Custom;
 
1119
    } else if (p=="letter") {
 
1120
        ret = RS2::Letter;
 
1121
    } else if (p=="legal") {
 
1122
        ret = RS2::Legal;
 
1123
    } else if (p=="executive") {
 
1124
        ret = RS2::Executive;
 
1125
    } else if (p=="a0") {
 
1126
        ret = RS2::A0;
 
1127
    } else if (p=="a1") {
 
1128
        ret = RS2::A1;
 
1129
    } else if (p=="a2") {
 
1130
        ret = RS2::A2;
 
1131
    } else if (p=="a3") {
 
1132
        ret = RS2::A3;
 
1133
    } else if (p=="a4") {
 
1134
        ret = RS2::A4;
 
1135
    } else if (p=="a5") {
 
1136
        ret = RS2::A5;
 
1137
    } else if (p=="a6") {
 
1138
        ret = RS2::A6;
 
1139
    } else if (p=="a7") {
 
1140
        ret = RS2::A7;
 
1141
    } else if (p=="a8") {
 
1142
        ret = RS2::A8;
 
1143
    } else if (p=="a9") {
 
1144
        ret = RS2::A9;
 
1145
    } else if (p=="b0") {
 
1146
        ret = RS2::B0;
 
1147
    } else if (p=="b1") {
 
1148
        ret = RS2::B1;
 
1149
    } else if (p=="b2") {
 
1150
        ret = RS2::B2;
 
1151
    } else if (p=="b3") {
 
1152
        ret = RS2::B3;
 
1153
    } else if (p=="b4") {
 
1154
        ret = RS2::B4;
 
1155
    } else if (p=="b5") {
 
1156
        ret = RS2::B5;
 
1157
    } else if (p=="b6") {
 
1158
        ret = RS2::B6;
 
1159
    } else if (p=="b7") {
 
1160
        ret = RS2::B7;
 
1161
    } else if (p=="b8") {
 
1162
        ret = RS2::B8;
 
1163
    } else if (p=="b9") {
 
1164
        ret = RS2::B9;
 
1165
    } else if (p=="b10") {
 
1166
        ret = RS2::B10;
 
1167
    }
 
1168
    /*else if (p=="c0") {
 
1169
           ret = RS2::C0;
 
1170
       } else if (p=="c1") {
 
1171
           ret = RS2::C1;
 
1172
       } else if (p=="c2") {
 
1173
           ret = RS2::C2;
 
1174
       } else if (p=="c3") {
 
1175
           ret = RS2::C3;
 
1176
       } else if (p=="c4") {
 
1177
           ret = RS2::C4;
 
1178
       } else if (p=="c5") {
 
1179
           ret = RS2::C5;
 
1180
       } else if (p=="c6") {
 
1181
           ret = RS2::C6;
 
1182
       } else if (p=="c7") {
 
1183
           ret = RS2::C7;
 
1184
       } else if (p=="c8") {
 
1185
           ret = RS2::C8;
 
1186
       } else if (p=="c9") {
 
1187
           ret = RS2::C9;
 
1188
       } else if (p=="c10") {
 
1189
           ret = RS2::C10;
 
1190
       }*/
 
1191
    else if (p=="c5e") {
 
1192
        ret = RS2::C5E;
 
1193
    } else if (p=="comm10e") {
 
1194
        ret = RS2::Comm10E;
 
1195
    } else if (p=="dle") {
 
1196
        ret = RS2::DLE;
 
1197
    } else if (p=="folio") {
 
1198
        ret = RS2::Folio;
 
1199
    //} else if (p=="ledger") {
 
1200
    //    ret = RS2::Ledger;
 
1201
    } else if (p=="tabloid") {
 
1202
        ret = RS2::Tabloid;
 
1203
    } else if (p=="npagesize") {
 
1204
        ret = RS2::NPageSize;
 
1205
    }
 
1206
 
 
1207
    return ret;
 
1208
}
 
1209
 
 
1210
 
 
1211
/**
 
1212
 * Performs some testing for the math class.
 
1213
 */
 
1214
void RS_Units::test() {
 
1215
    RS_String s;
 
1216
    double v;
 
1217
 
 
1218
    /*
 
1219
       std::cout << "RS_Units::test: formatLinear (decimal):\n";
 
1220
       v = 0.1;
 
1221
       s = RS_Units::formatLinear(v, RS2::Millimeter, RS2::Decimal,
 
1222
                                 3, false);
 
1223
       std::cout << "s: " << s << "\n";
 
1224
       assert(s=="0.1");
 
1225
       v = 0.01;
 
1226
       s = RS_Units::formatLinear(v, RS2::Millimeter, RS2::Decimal,
 
1227
                                 3, false);
 
1228
       std::cout << "s: " << s << "\n";
 
1229
       assert(s=="0.01");
 
1230
       v = 0.001;
 
1231
       s = RS_Units::formatLinear(v, RS2::Millimeter, RS2::Decimal,
 
1232
                                 3, false);
 
1233
       std::cout << "s: " << s << "\n";
 
1234
       assert(s=="0.001");
 
1235
       v = 0.009;
 
1236
       s = RS_Units::formatLinear(v, RS2::Millimeter, RS2::Decimal,
 
1237
                                 2, false);
 
1238
       std::cout << "s: " << s << "\n";
 
1239
       assert(s=="0.01");
 
1240
       v = 0.005;
 
1241
       s = RS_Units::formatLinear(v, RS2::Millimeter, RS2::Decimal,
 
1242
                                 2, false);
 
1243
       std::cout << "s: " << s << "\n";
 
1244
       assert(s=="0.01");
 
1245
       v = 0.0049999;
 
1246
       s = RS_Units::formatLinear(v, RS2::Millimeter, RS2::Decimal,
 
1247
                                 2, false);
 
1248
       std::cout << "s: " << s << "\n";
 
1249
       assert(s=="0");
 
1250
 
 
1251
       v = 0.1;
 
1252
       s = RS_Units::formatLinear(v, RS2::Millimeter, RS2::Decimal,
 
1253
                                 4, true);
 
1254
       std::cout << "s: " << s << "\n";
 
1255
       assert(s=="0.1mm");
 
1256
 
 
1257
 
 
1258
       std::cout << "RS_Units::test: formatLinear (fractional):\n";
 
1259
       v = 1.2;
 
1260
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1261
                                 6, false);
 
1262
       std::cout << "s: " << s << "\n";
 
1263
       assert(s=="1 13/64");
 
1264
 
 
1265
       v = 1.2;
 
1266
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1267
                                 8, false);
 
1268
       std::cout << "s: " << s << "\n";
 
1269
       assert(s=="1 51/256");
 
1270
 
 
1271
       v = 0.2;
 
1272
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1273
                                 8, false);
 
1274
       std::cout << "s: " << s << "\n";
 
1275
       assert(s=="51/256");
 
1276
 
 
1277
       v = 4.5;
 
1278
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1279
                                 6, true);
 
1280
       std::cout << "s: " << s << "\n";
 
1281
       assert(s=="4 1/2");
 
1282
 
 
1283
       v = 0.001;
 
1284
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1285
                                 0, false);
 
1286
       std::cout << "s: " << s << "\n";
 
1287
       assert(s=="0");
 
1288
 
 
1289
       v = 0.01;
 
1290
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1291
                                 8, false);
 
1292
       std::cout << "s: " << s << "\n";
 
1293
       assert(s=="3/256");
 
1294
 
 
1295
       v = 0.0078125;
 
1296
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1297
                                 8, false);
 
1298
       std::cout << "s: " << s << "\n";
 
1299
       assert(s=="1/128");
 
1300
 
 
1301
       v = 0.001;
 
1302
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1303
                                 8, false);
 
1304
       std::cout << "s: " << s << "\n";
 
1305
       assert(s=="0");
 
1306
 
 
1307
       v = 9.9999;
 
1308
       s = RS_Units::formatLinear(v, RS2::Inch, RS2::Fractional,
 
1309
                                 6, false);
 
1310
       std::cout << "s: " << s << "\n";
 
1311
       assert(s=="10");
 
1312
    */
 
1313
 
 
1314
    for (v=11.9999; v<12.0001; v+=0.0000001) {
 
1315
        for (int prec=0; prec<=6; ++prec) {
 
1316
            s = RS_Units::formatLinear(v, RS2::Inch, RS2::Architectural,
 
1317
                                       prec, true);
 
1318
                        // RVT_PORT changed  << s to s.ascii()
 
1319
            std::cout << "prec: " << prec << " v: " << v << " s: " << s.ascii() << "\n";
 
1320
        }
 
1321
    }
 
1322
 
 
1323
    /*for (v=0.0; v<10.0; v+=0.001) {
 
1324
        s = RS_Units::formatLinear(v, RS2::Foot, RS2::Fractional,
 
1325
                                  1.0/128.0, true);
 
1326
        std::cout << "v: " << v << " s: " << s << "\n";
 
1327
}*/
 
1328
 
 
1329
    /*
 
1330
    std::cout << "RS_Units::test: formatLinear (scientific):\n";
 
1331
    v = 0.001;
 
1332
    s = RS_Units::formatLinear(v, RS2::Millimeter, RS2::Scientific,
 
1333
                              0.0001, false);
 
1334
    std::cout << "s: " << s << "\n";
 
1335
    assert(s=="1.0e-3");
 
1336
    */
 
1337
 
 
1338
 
 
1339
    /*
 
1340
       std::cout << "RS_Units::test: formatAngle (deg / decimal):\n";
 
1341
       v = 0.0261799;
 
1342
       s = RS_Units::formatAngle(v, RS2::DegreesDecimal, 2);
 
1343
       std::cout << "s: " << s << "\n";
 
1344
       assert(s=="1.5∞");
 
1345
 
 
1346
       v = 0;
 
1347
       s = RS_Units::formatAngle(v, RS2::DegreesDecimal, 2);
 
1348
       std::cout << "s: " << s << "\n";
 
1349
       assert(s=="0∞");
 
1350
 
 
1351
       v = 1.5707963;
 
1352
       s = RS_Units::formatAngle(v, RS2::DegreesDecimal, 2);
 
1353
       std::cout << "s: " << s << "\n";
 
1354
       assert(s=="90∞");
 
1355
 
 
1356
       std::cout << "RS_Units::test: formatAngle (deg / d/m/s):\n";
 
1357
 
 
1358
       v = 0.0260926;
 
1359
       s = RS_Units::formatAngle(v, RS2::DegreesMinutesSeconds, 1);
 
1360
       std::cout << "s: " << s << "\n";
 
1361
       assert(s=="1∞ 29' 42\"");
 
1362
 
 
1363
       v = 0.0261799;
 
1364
       s = RS_Units::formatAngle(v, RS2::DegreesMinutesSeconds, 1);
 
1365
       std::cout << "s: " << s << "\n";
 
1366
       assert(s=="1∞ 30' 0\"");
 
1367
    */
 
1368
}
 
1369