Mercurial > ldforge / file comparison

comparison: src/types.cc

src/types.cc

changeset 603
47e7773c7841
parent 600
209e3f1f7b2c
child 604
01bdac75994a
equal deleted inserted replaced
602:ac1744536b33 603:47e7773c7841
28 #include "document.h" 28 #include "document.h"
29 29
30 // ============================================================================= 30 // =============================================================================
31 // ----------------------------------------------------------------------------- 31 // -----------------------------------------------------------------------------
32 str DoFormat (QList<StringFormatArg> args) 32 str DoFormat (QList<StringFormatArg> args)
33 { assert (args.size() >= 1); 33 {
34 assert (args.size() >= 1);
34 str text = args[0].value(); 35 str text = args[0].value();
35 36
36 for (uchar i = 1; i < args.size(); ++i) 37 for (uchar i = 1; i < args.size(); ++i)
37 text = text.arg (args[i].value()); 38 text = text.arg (args[i].value());
38 39
40 } 41 }
41 42
42 // ============================================================================= 43 // =============================================================================
43 // ----------------------------------------------------------------------------- 44 // -----------------------------------------------------------------------------
44 vertex::vertex (double x, double y, double z) 45 vertex::vertex (double x, double y, double z)
45 { m_coords[X] = x; 46 {
47 m_coords[X] = x;
46 m_coords[Y] = y; 48 m_coords[Y] = y;
47 m_coords[Z] = z; 49 m_coords[Z] = z;
48 } 50 }
49 51
50 // ============================================================================= 52 // =============================================================================
51 // ----------------------------------------------------------------------------- 53 // -----------------------------------------------------------------------------
52 void vertex::move (const vertex& other) 54 void vertex::move (const vertex& other)
53 { for_axes (ax) 55 {
56 for_axes (ax)
54 m_coords[ax] += other[ax]; 57 m_coords[ax] += other[ax];
55 } 58 }
56 59
57 // ============================================================================= 60 // =============================================================================
58 // ----------------------------------------------------------------------------- 61 // -----------------------------------------------------------------------------
59 double vertex::distanceTo (const vertex& other) const 62 double vertex::distanceTo (const vertex& other) const
60 { double dx = abs (x() - other.x()); 63 {
64 double dx = abs (x() - other.x());
61 double dy = abs (y() - other.y()); 65 double dy = abs (y() - other.y());
62 double dz = abs (z() - other.z()); 66 double dz = abs (z() - other.z());
63 return sqrt ((dx * dx) + (dy * dy) + (dz * dz)); 67 return sqrt ((dx * dx) + (dy * dy) + (dz * dz));
64 } 68 }
65 69
66 // ============================================================================= 70 // =============================================================================
67 // ----------------------------------------------------------------------------- 71 // -----------------------------------------------------------------------------
68 vertex vertex::midpoint (const vertex& other) 72 vertex vertex::midpoint (const vertex& other)
69 { vertex mid; 73 {
74 vertex mid;
70 75
71 for_axes (ax) 76 for_axes (ax)
72 mid[ax] = (m_coords[ax] + other[ax]) / 2; 77 mid[ax] = (m_coords[ax] + other[ax]) / 2;
73 78
74 return mid; 79 return mid;
75 } 80 }
76 81
77 // ============================================================================= 82 // =============================================================================
78 // ----------------------------------------------------------------------------- 83 // -----------------------------------------------------------------------------
79 str vertex::stringRep (bool mangled) const 84 str vertex::stringRep (bool mangled) const
80 { str fmtstr = "%1 %2 %3"; 85 {
86 str fmtstr = "%1 %2 %3";
81 87
82 if (mangled) 88 if (mangled)
83 fmtstr = "(%1, %2, %3)"; 89 fmtstr = "(%1, %2, %3)";
84 90
85 return fmt (fmtstr, coord (X), coord (Y), coord (Z)); 91 return fmt (fmtstr, coord (X), coord (Y), coord (Z));
86 } 92 }
87 93
88 // ============================================================================= 94 // =============================================================================
89 // ----------------------------------------------------------------------------- 95 // -----------------------------------------------------------------------------
90 void vertex::transform (matrix matr, vertex pos) 96 void vertex::transform (matrix matr, vertex pos)
91 { double x2 = (matr[0] * x()) + (matr[1] * y()) + (matr[2] * z()) + pos[X]; 97 {
98 double x2 = (matr[0] * x()) + (matr[1] * y()) + (matr[2] * z()) + pos[X];
92 double y2 = (matr[3] * x()) + (matr[4] * y()) + (matr[5] * z()) + pos[Y]; 99 double y2 = (matr[3] * x()) + (matr[4] * y()) + (matr[5] * z()) + pos[Y];
93 double z2 = (matr[6] * x()) + (matr[7] * y()) + (matr[8] * z()) + pos[Z]; 100 double z2 = (matr[6] * x()) + (matr[7] * y()) + (matr[8] * z()) + pos[Z];
94 101
95 x() = x2; 102 x() = x2;
96 y() = y2; 103 y() = y2;
98 } 105 }
99 106
100 // ============================================================================= 107 // =============================================================================
101 // ----------------------------------------------------------------------------- 108 // -----------------------------------------------------------------------------
102 vertex vertex::operator-() const 109 vertex vertex::operator-() const
103 { return vertex (-m_coords[X], -m_coords[Y], -m_coords[Z]); 110 {
111 return vertex (-m_coords[X], -m_coords[Y], -m_coords[Z]);
104 } 112 }
105 113
106 // ============================================================================= 114 // =============================================================================
107 // ----------------------------------------------------------------------------- 115 // -----------------------------------------------------------------------------
108 bool vertex::operator!= (const vertex& other) const 116 bool vertex::operator!= (const vertex& other) const
109 { return !operator== (other); 117 {
118 return !operator== (other);
110 } 119 }
111 120
112 // ============================================================================= 121 // =============================================================================
113 // ----------------------------------------------------------------------------- 122 // -----------------------------------------------------------------------------
114 double& vertex::operator[] (const Axis ax) 123 double& vertex::operator[] (const Axis ax)
115 { return coord ( (int) ax); 124 {
125 return coord ( (int) ax);
116 } 126 }
117 127
118 const double& vertex::operator[] (const Axis ax) const 128 const double& vertex::operator[] (const Axis ax) const
119 { return coord ( (int) ax); 129 {
130 return coord ( (int) ax);
120 } 131 }
121 132
122 double& vertex::operator[] (const int ax) 133 double& vertex::operator[] (const int ax)
123 { return coord (ax); 134 {
135 return coord (ax);
124 } 136 }
125 137
126 const double& vertex::operator[] (const int ax) const 138 const double& vertex::operator[] (const int ax) const
127 { return coord (ax); 139 {
140 return coord (ax);
128 } 141 }
129 142
130 // ============================================================================= 143 // =============================================================================
131 // ----------------------------------------------------------------------------- 144 // -----------------------------------------------------------------------------
132 bool vertex::operator== (const vertex& other) const 145 bool vertex::operator== (const vertex& other) const
133 { return coord (X) == other[X] && 146 {
147 return coord (X) == other[X] &&
134 coord (Y) == other[Y] && 148 coord (Y) == other[Y] &&
135 coord (Z) == other[Z]; 149 coord (Z) == other[Z];
136 } 150 }
137 151
138 // ============================================================================= 152 // =============================================================================
139 // ----------------------------------------------------------------------------- 153 // -----------------------------------------------------------------------------
140 vertex& vertex::operator/= (const double d) 154 vertex& vertex::operator/= (const double d)
141 { for_axes (ax) 155 {
156 for_axes (ax)
142 m_coords[ax] /= d; 157 m_coords[ax] /= d;
143 158
144 return *this; 159 return *this;
145 } 160 }
146 161
147 // ============================================================================= 162 // =============================================================================
148 // ----------------------------------------------------------------------------- 163 // -----------------------------------------------------------------------------
149 vertex vertex::operator/ (const double d) const 164 vertex vertex::operator/ (const double d) const
150 { vertex other (*this); 165 {
166 vertex other (*this);
151 return other /= d; 167 return other /= d;
152 } 168 }
153 169
154 // ============================================================================= 170 // =============================================================================
155 // ----------------------------------------------------------------------------- 171 // -----------------------------------------------------------------------------
156 vertex& vertex::operator+= (const vertex& other) 172 vertex& vertex::operator+= (const vertex& other)
157 { move (other); 173 {
174 move (other);
158 return *this; 175 return *this;
159 } 176 }
160 177
161 // ============================================================================= 178 // =============================================================================
162 // ----------------------------------------------------------------------------- 179 // -----------------------------------------------------------------------------
163 vertex vertex::operator+ (const vertex& other) const 180 vertex vertex::operator+ (const vertex& other) const
164 { vertex newvert (*this); 181 {
182 vertex newvert (*this);
165 newvert.move (other); 183 newvert.move (other);
166 return newvert; 184 return newvert;
167 } 185 }
168 186
169 // ============================================================================= 187 // =============================================================================
170 // ----------------------------------------------------------------------------- 188 // -----------------------------------------------------------------------------
171 int vertex::operator< (const vertex& other) const 189 int vertex::operator< (const vertex& other) const
172 { if (operator== (other)) 190 {
191 if (operator== (other))
173 return false; 192 return false;
174 193
175 if (coord (X) < other[X]) 194 if (coord (X) < other[X])
176 return true; 195 return true;
177 196
188 } 207 }
189 208
190 // ============================================================================= 209 // =============================================================================
191 // ----------------------------------------------------------------------------- 210 // -----------------------------------------------------------------------------
192 matrix::matrix (double vals[]) 211 matrix::matrix (double vals[])
193 { for (int i = 0; i < 9; ++i) 212 {
213 for (int i = 0; i < 9; ++i)
194 m_vals[i] = vals[i]; 214 m_vals[i] = vals[i];
195 } 215 }
196 216
197 // ============================================================================= 217 // =============================================================================
198 // ----------------------------------------------------------------------------- 218 // -----------------------------------------------------------------------------
199 matrix::matrix (double fillval) 219 matrix::matrix (double fillval)
200 { for (int i = 0; i < 9; ++i) 220 {
221 for (int i = 0; i < 9; ++i)
201 m_vals[i] = fillval; 222 m_vals[i] = fillval;
202 } 223 }
203 224
204 // ============================================================================= 225 // =============================================================================
205 // ----------------------------------------------------------------------------- 226 // -----------------------------------------------------------------------------
206 matrix::matrix (initlist<double> vals) 227 matrix::matrix (initlist<double> vals)
207 { assert (vals.size() == 9); 228 {
229 assert (vals.size() == 9);
208 memcpy (&m_vals[0], & (*vals.begin()), sizeof m_vals); 230 memcpy (&m_vals[0], & (*vals.begin()), sizeof m_vals);
209 } 231 }
210 232
211 // ============================================================================= 233 // =============================================================================
212 // ----------------------------------------------------------------------------- 234 // -----------------------------------------------------------------------------
213 void matrix::puts() const 235 void matrix::puts() const
214 { for (int i = 0; i < 3; ++i) 236 {
215 { for (int j = 0; j < 3; ++j) 237 for (int i = 0; i < 3; ++i)
238 {
239 for (int j = 0; j < 3; ++j)
216 log ("%1\t", m_vals[ (i * 3) + j]); 240 log ("%1\t", m_vals[ (i * 3) + j]);
217 241
218 log ("\n"); 242 log ("\n");
219 } 243 }
220 } 244 }
221 245
222 // ============================================================================= 246 // =============================================================================
223 // ----------------------------------------------------------------------------- 247 // -----------------------------------------------------------------------------
224 str matrix::stringRep() const 248 str matrix::stringRep() const
225 { str val; 249 {
250 str val;
226 251
227 for (int i = 0; i < 9; ++i) 252 for (int i = 0; i < 9; ++i)
228 { if (i > 0) 253 {
254 if (i > 0)
229 val += ' '; 255 val += ' ';
230 256
231 val += str::number (m_vals[i]); 257 val += str::number (m_vals[i]);
232 } 258 }
233 259
235 } 261 }
236 262
237 // ============================================================================= 263 // =============================================================================
238 // ----------------------------------------------------------------------------- 264 // -----------------------------------------------------------------------------
239 void matrix::zero() 265 void matrix::zero()
240 { memset (&m_vals[0], 0, sizeof m_vals); 266 {
267 memset (&m_vals[0], 0, sizeof m_vals);
241 } 268 }
242 269
243 // ============================================================================= 270 // =============================================================================
244 // ----------------------------------------------------------------------------- 271 // -----------------------------------------------------------------------------
245 matrix matrix::mult (matrix other) const 272 matrix matrix::mult (matrix other) const
246 { matrix val; 273 {
274 matrix val;
247 val.zero(); 275 val.zero();
248 276
249 for (int i = 0; i < 3; ++i) 277 for (int i = 0; i < 3; ++i)
250 for (int j = 0; j < 3; ++j) 278 for (int j = 0; j < 3; ++j)
251 for (int k = 0; k < 3; ++k) 279 for (int k = 0; k < 3; ++k)
255 } 283 }
256 284
257 // ============================================================================= 285 // =============================================================================
258 // ----------------------------------------------------------------------------- 286 // -----------------------------------------------------------------------------
259 matrix& matrix::operator= (matrix other) 287 matrix& matrix::operator= (matrix other)
260 { memcpy (&m_vals[0], &other.m_vals[0], sizeof m_vals); 288 {
289 memcpy (&m_vals[0], &other.m_vals[0], sizeof m_vals);
261 return *this; 290 return *this;
262 } 291 }
263 292
264 // ============================================================================= 293 // =============================================================================
265 // ----------------------------------------------------------------------------- 294 // -----------------------------------------------------------------------------
266 double matrix::getDeterminant() const 295 double matrix::getDeterminant() const
267 { return (val (0) * val (4) * val (8)) + 296 {
297 return (val (0) * val (4) * val (8)) +
268 (val (1) * val (5) * val (6)) + 298 (val (1) * val (5) * val (6)) +
269 (val (2) * val (3) * val (7)) - 299 (val (2) * val (3) * val (7)) -
270 (val (2) * val (4) * val (6)) - 300 (val (2) * val (4) * val (6)) -
271 (val (1) * val (3) * val (8)) - 301 (val (1) * val (3) * val (8)) -
272 (val (0) * val (5) * val (7)); 302 (val (0) * val (5) * val (7));
273 } 303 }
274 304
275 // ============================================================================= 305 // =============================================================================
276 // ----------------------------------------------------------------------------- 306 // -----------------------------------------------------------------------------
277 bool matrix::operator== (const matrix& other) const 307 bool matrix::operator== (const matrix& other) const
278 { for (int i = 0; i < 9; ++i) 308 {
309 for (int i = 0; i < 9; ++i)
279 if (val (i) != other[i]) 310 if (val (i) != other[i])
280 return false; 311 return false;
281 312
282 return true; 313 return true;
283 } 314 }
284 315
285 // ============================================================================= 316 // =============================================================================
286 // ----------------------------------------------------------------------------- 317 // -----------------------------------------------------------------------------
287 StringFormatArg::StringFormatArg (const str& v) 318 StringFormatArg::StringFormatArg (const str& v)
288 { m_val = v; 319 {
320 m_val = v;
289 } 321 }
290 322
291 StringFormatArg::StringFormatArg (const char& v) 323 StringFormatArg::StringFormatArg (const char& v)
292 { m_val = v; 324 {
325 m_val = v;
293 } 326 }
294 327
295 StringFormatArg::StringFormatArg (const uchar& v) 328 StringFormatArg::StringFormatArg (const uchar& v)
296 { m_val = v; 329 {
330 m_val = v;
297 } 331 }
298 332
299 StringFormatArg::StringFormatArg (const QChar& v) 333 StringFormatArg::StringFormatArg (const QChar& v)
300 { m_val = v; 334 {
335 m_val = v;
301 } 336 }
302 337
303 StringFormatArg::StringFormatArg (const float& v) 338 StringFormatArg::StringFormatArg (const float& v)
304 { m_val = str::number (v); 339 {
340 m_val = str::number (v);
305 } 341 }
306 342
307 StringFormatArg::StringFormatArg (const double& v) 343 StringFormatArg::StringFormatArg (const double& v)
308 { m_val = str::number (v); 344 {
345 m_val = str::number (v);
309 } 346 }
310 347
311 StringFormatArg::StringFormatArg (const vertex& v) 348 StringFormatArg::StringFormatArg (const vertex& v)
312 { m_val = v.stringRep (false); 349 {
350 m_val = v.stringRep (false);
313 } 351 }
314 352
315 StringFormatArg::StringFormatArg (const matrix& v) 353 StringFormatArg::StringFormatArg (const matrix& v)
316 { m_val = v.stringRep(); 354 {
355 m_val = v.stringRep();
317 } 356 }
318 357
319 StringFormatArg::StringFormatArg (const char* v) 358 StringFormatArg::StringFormatArg (const char* v)
320 { m_val = v; 359 {
360 m_val = v;
321 } 361 }
322 362
323 StringFormatArg::StringFormatArg (const void* v) 363 StringFormatArg::StringFormatArg (const void* v)
324 { m_val.sprintf ("%p", v); 364 {
365 m_val.sprintf ("%p", v);
325 } 366 }
326 367
327 // ============================================================================= 368 // =============================================================================
328 // ----------------------------------------------------------------------------- 369 // -----------------------------------------------------------------------------
329 File::File() 370 File::File()
330 { // Make a null file 371 {
372 // Make a null file
331 m_file = null; 373 m_file = null;
332 m_textstream = null; 374 m_textstream = null;
333 } 375 }
334 376
335 File::File (str path, OpenType rtype) 377 File::File (str path, OpenType rtype)
336 { m_file = null; 378 {
379 m_file = null;
337 m_path = path; 380 m_path = path;
338 open (path, rtype); 381 open (path, rtype);
339 } 382 }
340 383
341 File::File (FILE* fp, OpenType rtype) 384 File::File (FILE* fp, OpenType rtype)
342 { m_file = null; 385 {
386 m_file = null;
343 open (fp, rtype); 387 open (fp, rtype);
344 } 388 }
345 389
346 // ============================================================================= 390 // =============================================================================
347 // ----------------------------------------------------------------------------- 391 // -----------------------------------------------------------------------------
348 File::~File() 392 File::~File()
349 { if (m_file) 393 {
350 { m_file->close(); 394 if (m_file)
395 {
396 m_file->close();
351 delete m_file; 397 delete m_file;
352 398
353 if (m_textstream) 399 if (m_textstream)
354 delete m_textstream; 400 delete m_textstream;
355 } 401 }
356 } 402 }
357 403
358 // ============================================================================= 404 // =============================================================================
359 // ----------------------------------------------------------------------------- 405 // -----------------------------------------------------------------------------
360 bool File::open (FILE* fp, OpenType rtype) 406 bool File::open (FILE* fp, OpenType rtype)
361 { return open ("", rtype, fp); 407 {
408 return open ("", rtype, fp);
362 } 409 }
363 410
364 bool File::open (str path, OpenType rtype, FILE* fp) 411 bool File::open (str path, OpenType rtype, FILE* fp)
365 { close(); 412 {
413 close();
366 414
367 if (!m_file) 415 if (!m_file)
368 m_file = new QFile; 416 m_file = new QFile;
369 417
370 m_file->setFileName (path); 418 m_file->setFileName (path);
379 result = m_file->open (fp, mode); 427 result = m_file->open (fp, mode);
380 else 428 else
381 result = m_file->open (mode); 429 result = m_file->open (mode);
382 430
383 if (result) 431 if (result)
384 { m_textstream = new QTextStream (m_file); 432 {
433 m_textstream = new QTextStream (m_file);
385 m_path = path; 434 m_path = path;
386 return true; 435 return true;
387 } 436 }
388 437
389 delete m_file; 438 delete m_file;
392 } 441 }
393 442
394 // ============================================================================= 443 // =============================================================================
395 // ----------------------------------------------------------------------------- 444 // -----------------------------------------------------------------------------
396 File::iterator File::begin() 445 File::iterator File::begin()
397 { return iterator (this); 446 {
447 return iterator (this);
398 } 448 }
399 449
400 File::iterator& File::end() 450 File::iterator& File::end()
401 { return m_endIterator; 451 {
452 return m_endIterator;
402 } 453 }
403 454
404 // ============================================================================= 455 // =============================================================================
405 // ----------------------------------------------------------------------------- 456 // -----------------------------------------------------------------------------
406 void File::write (str msg) 457 void File::write (str msg)
407 { m_file->write (msg.toUtf8(), msg.length()); 458 {
459 m_file->write (msg.toUtf8(), msg.length());
408 } 460 }
409 461
410 // ============================================================================= 462 // =============================================================================
411 // ----------------------------------------------------------------------------- 463 // -----------------------------------------------------------------------------
412 bool File::readLine (str& line) 464 bool File::readLine (str& line)
413 { if (!m_textstream || m_textstream->atEnd()) 465 {
466 if (!m_textstream || m_textstream->atEnd())
414 return false; 467 return false;
415 468
416 line = m_textstream->readLine(); 469 line = m_textstream->readLine();
417 return true; 470 return true;
418 } 471 }
419 472
420 // ============================================================================= 473 // =============================================================================
421 // ----------------------------------------------------------------------------- 474 // -----------------------------------------------------------------------------
422 bool File::atEnd() const 475 bool File::atEnd() const
423 { assert (m_textstream != null); 476 {
477 assert (m_textstream != null);
424 return m_textstream->atEnd(); 478 return m_textstream->atEnd();
425 } 479 }
426 480
427 // ============================================================================= 481 // =============================================================================
428 // ----------------------------------------------------------------------------- 482 // -----------------------------------------------------------------------------
429 bool File::isNull() const 483 bool File::isNull() const
430 { return m_file == null; 484 {
485 return m_file == null;
431 } 486 }
432 487
433 bool File::operator!() const 488 bool File::operator!() const
434 { return isNull(); 489 {
490 return isNull();
435 } 491 }
436 492
437 // ============================================================================= 493 // =============================================================================
438 // ----------------------------------------------------------------------------- 494 // -----------------------------------------------------------------------------
439 void File::close() 495 void File::close()
440 { if (!m_file) 496 {
497 if (!m_file)
441 return; 498 return;
442 499
443 delete m_file; 500 delete m_file;
444 m_file = null; 501 m_file = null;
445 502
446 if (m_textstream) 503 if (m_textstream)
447 { delete m_textstream; 504 {
505 delete m_textstream;
448 m_textstream = null; 506 m_textstream = null;
449 } 507 }
450 } 508 }
451 509
452 // ============================================================================= 510 // =============================================================================
453 // ----------------------------------------------------------------------------- 511 // -----------------------------------------------------------------------------
454 bool File::flush() 512 bool File::flush()
455 { return m_file->flush(); 513 {
514 return m_file->flush();
456 } 515 }
457 516
458 // ============================================================================= 517 // =============================================================================
459 // ----------------------------------------------------------------------------- 518 // -----------------------------------------------------------------------------
460 File::operator bool() const 519 File::operator bool() const
461 { return !isNull(); 520 {
521 return !isNull();
462 } 522 }
463 523
464 // ============================================================================= 524 // =============================================================================
465 // ----------------------------------------------------------------------------- 525 // -----------------------------------------------------------------------------
466 void File::rewind() 526 void File::rewind()
467 { m_file->seek (0); 527 {
528 m_file->seek (0);
468 } 529 }
469 530
470 // ============================================================================= 531 // =============================================================================
471 // ----------------------------------------------------------------------------- 532 // -----------------------------------------------------------------------------
472 File::iterator::iterator (File* f) : m_file (f) 533 File::iterator::iterator (File* f) : m_file (f)
473 { operator++(); 534 {
535 operator++();
474 } 536 }
475 537
476 // ============================================================================= 538 // =============================================================================
477 // ----------------------------------------------------------------------------- 539 // -----------------------------------------------------------------------------
478 void File::iterator::operator++() 540 void File::iterator::operator++()
479 { m_gotdata = m_file->readLine (m_text); 541 {
542 m_gotdata = m_file->readLine (m_text);
480 } 543 }
481 544
482 // ============================================================================= 545 // =============================================================================
483 // ----------------------------------------------------------------------------- 546 // -----------------------------------------------------------------------------
484 str File::iterator::operator*() 547 str File::iterator::operator*()
485 { return m_text; 548 {
549 return m_text;
486 } 550 }
487 551
488 // ============================================================================= 552 // =============================================================================
489 // The prime contestant for the weirdest operator== 2013 award? 553 // The prime contestant for the weirdest operator== 2013 award?
490 // ----------------------------------------------------------------------------- 554 // -----------------------------------------------------------------------------
491 bool File::iterator::operator== (File::iterator& other) 555 bool File::iterator::operator== (File::iterator& other)
492 { return (other.m_file == null && !m_gotdata); 556 {
557 return (other.m_file == null && !m_gotdata);
493 } 558 }
494 559
495 // ============================================================================= 560 // =============================================================================
496 // ----------------------------------------------------------------------------- 561 // -----------------------------------------------------------------------------
497 bool File::iterator::operator!= (File::iterator& other) 562 bool File::iterator::operator!= (File::iterator& other)
498 { return !operator== (other); 563 {
564 return !operator== (other);
499 } 565 }
500 566
501 // ============================================================================= 567 // =============================================================================
502 // ----------------------------------------------------------------------------- 568 // -----------------------------------------------------------------------------
503 LDBoundingBox::LDBoundingBox() 569 LDBoundingBox::LDBoundingBox()
504 { reset(); 570 {
571 reset();
505 } 572 }
506 573
507 // ============================================================================= 574 // =============================================================================
508 // ----------------------------------------------------------------------------- 575 // -----------------------------------------------------------------------------
509 void LDBoundingBox::calculate() 576 void LDBoundingBox::calculate()
510 { reset(); 577 {
578 reset();
511 579
512 if (!getCurrentDocument()) 580 if (!getCurrentDocument())
513 return; 581 return;
514 582
515 for (LDObject* obj : getCurrentDocument()->getObjects()) 583 for (LDObject* obj : getCurrentDocument()->getObjects())
517 } 585 }
518 586
519 // ============================================================================= 587 // =============================================================================
520 // ----------------------------------------------------------------------------- 588 // -----------------------------------------------------------------------------
521 void LDBoundingBox::calcObject (LDObject* obj) 589 void LDBoundingBox::calcObject (LDObject* obj)
522 { switch (obj->getType()) 590 {
523 { case LDObject::Line: 591 switch (obj->getType())
592 {
593 case LDObject::Line:
524 case LDObject::Triangle: 594 case LDObject::Triangle:
525 case LDObject::Quad: 595 case LDObject::Quad:
526 case LDObject::CondLine: 596 case LDObject::CondLine:
527 { for (int i = 0; i < obj->vertices(); ++i) 597 {
598 for (int i = 0; i < obj->vertices(); ++i)
528 calcVertex (obj->getVertex (i)); 599 calcVertex (obj->getVertex (i));
529 } break; 600 } break;
530 601
531 case LDObject::Subfile: 602 case LDObject::Subfile:
532 { LDSubfile* ref = static_cast<LDSubfile*> (obj); 603 {
604 LDSubfile* ref = static_cast<LDSubfile*> (obj);
533 QList<LDObject*> objs = ref->inlineContents (LDSubfile::DeepCacheInline); 605 QList<LDObject*> objs = ref->inlineContents (LDSubfile::DeepCacheInline);
534 606
535 for (LDObject * obj : objs) 607 for (LDObject * obj : objs)
536 { calcObject (obj); 608 {
609 calcObject (obj);
537 obj->deleteSelf(); 610 obj->deleteSelf();
538 } 611 }
539 } 612 }
540 break; 613 break;
541 614
545 } 618 }
546 619
547 // ============================================================================= 620 // =============================================================================
548 // ----------------------------------------------------------------------------- 621 // -----------------------------------------------------------------------------
549 LDBoundingBox& LDBoundingBox::operator<< (const vertex& v) 622 LDBoundingBox& LDBoundingBox::operator<< (const vertex& v)
550 { calcVertex (v); 623 {
624 calcVertex (v);
551 return *this; 625 return *this;
552 } 626 }
553 627
554 // ============================================================================= 628 // =============================================================================
555 // ----------------------------------------------------------------------------- 629 // -----------------------------------------------------------------------------
556 LDBoundingBox& LDBoundingBox::operator<< (LDObject* obj) 630 LDBoundingBox& LDBoundingBox::operator<< (LDObject* obj)
557 { calcObject (obj); 631 {
632 calcObject (obj);
558 return *this; 633 return *this;
559 } 634 }
560 635
561 // ============================================================================= 636 // =============================================================================
562 // ----------------------------------------------------------------------------- 637 // -----------------------------------------------------------------------------
563 void LDBoundingBox::calcVertex (const vertex& v) 638 void LDBoundingBox::calcVertex (const vertex& v)
564 { for_axes (ax) 639 {
565 { if (v[ax] < m_Vertex0[ax]) 640 for_axes (ax)
641 {
642 if (v[ax] < m_Vertex0[ax])
566 m_Vertex0[ax] = v[ax]; 643 m_Vertex0[ax] = v[ax];
567 644
568 if (v[ax] > m_Vertex1[ax]) 645 if (v[ax] > m_Vertex1[ax])
569 m_Vertex1[ax] = v[ax]; 646 m_Vertex1[ax] = v[ax];
570 } 647 }
573 } 650 }
574 651
575 // ============================================================================= 652 // =============================================================================
576 // ----------------------------------------------------------------------------- 653 // -----------------------------------------------------------------------------
577 void LDBoundingBox::reset() 654 void LDBoundingBox::reset()
578 { m_Vertex0[X] = m_Vertex0[Y] = m_Vertex0[Z] = 0x7FFFFFFF; 655 {
656 m_Vertex0[X] = m_Vertex0[Y] = m_Vertex0[Z] = 0x7FFFFFFF;
579 m_Vertex1[X] = m_Vertex1[Y] = m_Vertex1[Z] = 0xFFFFFFFF; 657 m_Vertex1[X] = m_Vertex1[Y] = m_Vertex1[Z] = 0xFFFFFFFF;
580 658
581 setEmpty (true); 659 setEmpty (true);
582 } 660 }
583 661
584 // ============================================================================= 662 // =============================================================================
585 // ----------------------------------------------------------------------------- 663 // -----------------------------------------------------------------------------
586 double LDBoundingBox::size() const 664 double LDBoundingBox::size() const
587 { double xscale = (m_Vertex0[X] - m_Vertex1[X]); 665 {
666 double xscale = (m_Vertex0[X] - m_Vertex1[X]);
588 double yscale = (m_Vertex0[Y] - m_Vertex1[Y]); 667 double yscale = (m_Vertex0[Y] - m_Vertex1[Y]);
589 double zscale = (m_Vertex0[Z] - m_Vertex1[Z]); 668 double zscale = (m_Vertex0[Z] - m_Vertex1[Z]);
590 double size = zscale; 669 double size = zscale;
591 670
592 if (xscale > yscale) 671 if (xscale > yscale)
593 { if (xscale > zscale) 672 {
673 if (xscale > zscale)
594 size = xscale; 674 size = xscale;
595 } 675 }
596 elif (yscale > zscale) 676 elif (yscale > zscale)
597 size = yscale; 677 size = yscale;
598 678
603 } 683 }
604 684
605 // ============================================================================= 685 // =============================================================================
606 // ----------------------------------------------------------------------------- 686 // -----------------------------------------------------------------------------
607 vertex LDBoundingBox::center() const 687 vertex LDBoundingBox::center() const
608 { return vertex ( 688 {
689 return vertex (
609 (m_Vertex0[X] + m_Vertex1[X]) / 2, 690 (m_Vertex0[X] + m_Vertex1[X]) / 2,
610 (m_Vertex0[Y] + m_Vertex1[Y]) / 2, 691 (m_Vertex0[Y] + m_Vertex1[Y]) / 2,
611 (m_Vertex0[Z] + m_Vertex1[Z]) / 2); 692 (m_Vertex0[Z] + m_Vertex1[Z]) / 2);
612 } 693 }

Mercurial Repository: ldforge

mercurial