Mercurial > ldforge / file comparison

comparison: src/Types.cc

src/Types.cc

changeset 639
851634b85893
parent 638
382226e40865
child 640
d4dda62c6600
equal deleted inserted replaced
638:382226e40865 639:851634b85893
26 #include "Misc.h" 26 #include "Misc.h"
27 #include "LDObject.h" 27 #include "LDObject.h"
28 #include "Document.h" 28 #include "Document.h"
29 29
30 // ============================================================================= 30 // =============================================================================
31 // ----------------------------------------------------------------------------- 31 //
32 QString DoFormat (QList<StringFormatArg> args) 32 QString DoFormat (QList<StringFormatArg> args)
33 { 33 {
34 assert (args.size() >= 1); 34 assert (args.size() >= 1);
35 QString text = args[0].value(); 35 QString text = args[0].value();
36 36
39 39
40 return text; 40 return text;
41 } 41 }
42 42
43 // ============================================================================= 43 // =============================================================================
44 // ----------------------------------------------------------------------------- 44 //
45 Vertex::Vertex (double x, double y, double z) 45 Vertex::Vertex (double x, double y, double z)
46 { 46 {
47 m_coords[X] = x; 47 m_coords[X] = x;
48 m_coords[Y] = y; 48 m_coords[Y] = y;
49 m_coords[Z] = z; 49 m_coords[Z] = z;
50 } 50 }
51 51
52 // ============================================================================= 52 // =============================================================================
53 // ----------------------------------------------------------------------------- 53 //
54 void Vertex::move (const Vertex& other) 54 void Vertex::move (const Vertex& other)
55 { 55 {
56 for_axes (ax) 56 for_axes (ax)
57 m_coords[ax] += other[ax]; 57 m_coords[ax] += other[ax];
58 } 58 }
59 59
60 // ============================================================================= 60 // =============================================================================
61 // ----------------------------------------------------------------------------- 61 //
62 double Vertex::distanceTo (const Vertex& other) const 62 double Vertex::distanceTo (const Vertex& other) const
63 { 63 {
64 double dx = abs (x() - other.x()); 64 double dx = abs (x() - other.x());
65 double dy = abs (y() - other.y()); 65 double dy = abs (y() - other.y());
66 double dz = abs (z() - other.z()); 66 double dz = abs (z() - other.z());
67 return sqrt ((dx * dx) + (dy * dy) + (dz * dz)); 67 return sqrt ((dx * dx) + (dy * dy) + (dz * dz));
68 } 68 }
69 69
70 // ============================================================================= 70 // =============================================================================
71 // ----------------------------------------------------------------------------- 71 //
72 Vertex Vertex::midpoint (const Vertex& other) 72 Vertex Vertex::midpoint (const Vertex& other)
73 { 73 {
74 Vertex mid; 74 Vertex mid;
75 75
76 for_axes (ax) 76 for_axes (ax)
78 78
79 return mid; 79 return mid;
80 } 80 }
81 81
82 // ============================================================================= 82 // =============================================================================
83 // ----------------------------------------------------------------------------- 83 //
84 QString Vertex::toString (bool mangled) const 84 QString Vertex::toString (bool mangled) const
85 { 85 {
86 QString fmtstr = "%1 %2 %3"; 86 QString fmtstr = "%1 %2 %3";
87 87
88 if (mangled) 88 if (mangled)
90 90
91 return fmt (fmtstr, x(), y(), z()); 91 return fmt (fmtstr, x(), y(), z());
92 } 92 }
93 93
94 // ============================================================================= 94 // =============================================================================
95 // ----------------------------------------------------------------------------- 95 //
96 void Vertex::transform (const Matrix& matr, const Vertex& pos) 96 void Vertex::transform (const Matrix& matr, const Vertex& pos)
97 { 97 {
98 double x2 = (matr[0] * x()) + (matr[1] * y()) + (matr[2] * z()) + pos[X]; 98 double x2 = (matr[0] * x()) + (matr[1] * y()) + (matr[2] * z()) + pos[X];
99 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];
100 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];
103 y() = y2; 103 y() = y2;
104 z() = z2; 104 z() = z2;
105 } 105 }
106 106
107 // ============================================================================= 107 // =============================================================================
108 // ----------------------------------------------------------------------------- 108 //
109 Vertex Vertex::operator-() const 109 Vertex Vertex::operator-() const
110 { 110 {
111 return Vertex (-m_coords[X], -m_coords[Y], -m_coords[Z]); 111 return Vertex (-m_coords[X], -m_coords[Y], -m_coords[Z]);
112 } 112 }
113 113
114 // ============================================================================= 114 // =============================================================================
115 // ----------------------------------------------------------------------------- 115 //
116 bool Vertex::operator!= (const Vertex& other) const 116 bool Vertex::operator!= (const Vertex& other) const
117 { 117 {
118 return !operator== (other); 118 return !operator== (other);
119 } 119 }
120 120
121 // ============================================================================= 121 // =============================================================================
122 // ----------------------------------------------------------------------------- 122 //
123 bool Vertex::operator== (const Vertex& other) const 123 bool Vertex::operator== (const Vertex& other) const
124 { 124 {
125 return getCoordinate (X) == other[X] && 125 return getCoordinate (X) == other[X] &&
126 getCoordinate (Y) == other[Y] && 126 getCoordinate (Y) == other[Y] &&
127 getCoordinate (Z) == other[Z]; 127 getCoordinate (Z) == other[Z];
128 } 128 }
129 129
130 // ============================================================================= 130 // =============================================================================
131 // ----------------------------------------------------------------------------- 131 //
132 Vertex& Vertex::operator/= (const double d) 132 Vertex& Vertex::operator/= (const double d)
133 { 133 {
134 for_axes (ax) 134 for_axes (ax)
135 m_coords[ax] /= d; 135 m_coords[ax] /= d;
136 136
137 return *this; 137 return *this;
138 } 138 }
139 139
140 // ============================================================================= 140 // =============================================================================
141 // ----------------------------------------------------------------------------- 141 //
142 Vertex Vertex::operator/ (const double d) const 142 Vertex Vertex::operator/ (const double d) const
143 { 143 {
144 Vertex other (*this); 144 Vertex other (*this);
145 return other /= d; 145 return other /= d;
146 } 146 }
147 147
148 // ============================================================================= 148 // =============================================================================
149 // ----------------------------------------------------------------------------- 149 //
150 Vertex& Vertex::operator+= (const Vertex& other) 150 Vertex& Vertex::operator+= (const Vertex& other)
151 { 151 {
152 move (other); 152 move (other);
153 return *this; 153 return *this;
154 } 154 }
155 155
156 // ============================================================================= 156 // =============================================================================
157 // ----------------------------------------------------------------------------- 157 //
158 Vertex Vertex::operator+ (const Vertex& other) const 158 Vertex Vertex::operator+ (const Vertex& other) const
159 { 159 {
160 Vertex newvert (*this); 160 Vertex newvert (*this);
161 newvert.move (other); 161 newvert.move (other);
162 return newvert; 162 return newvert;
163 } 163 }
164 164
165 // ============================================================================= 165 // =============================================================================
166 // ----------------------------------------------------------------------------- 166 //
167 int Vertex::operator< (const Vertex& other) const 167 int Vertex::operator< (const Vertex& other) const
168 { 168 {
169 if (operator== (other)) 169 if (operator== (other))
170 return false; 170 return false;
171 171
183 183
184 return getCoordinate (Z) < other[Z]; 184 return getCoordinate (Z) < other[Z];
185 } 185 }
186 186
187 // ============================================================================= 187 // =============================================================================
188 // ----------------------------------------------------------------------------- 188 //
189 Matrix::Matrix (double vals[]) 189 Matrix::Matrix (double vals[])
190 { 190 {
191 for (int i = 0; i < 9; ++i) 191 for (int i = 0; i < 9; ++i)
192 m_vals[i] = vals[i]; 192 m_vals[i] = vals[i];
193 } 193 }
194 194
195 // ============================================================================= 195 // =============================================================================
196 // ----------------------------------------------------------------------------- 196 //
197 Matrix::Matrix (double fillval) 197 Matrix::Matrix (double fillval)
198 { 198 {
199 for (int i = 0; i < 9; ++i) 199 for (int i = 0; i < 9; ++i)
200 m_vals[i] = fillval; 200 m_vals[i] = fillval;
201 } 201 }
202 202
203 // ============================================================================= 203 // =============================================================================
204 // ----------------------------------------------------------------------------- 204 //
205 Matrix::Matrix (initlist<double> vals) 205 Matrix::Matrix (initlist<double> vals)
206 { 206 {
207 assert (vals.size() == 9); 207 assert (vals.size() == 9);
208 memcpy (&m_vals[0], & (*vals.begin()), sizeof m_vals); 208 memcpy (&m_vals[0], & (*vals.begin()), sizeof m_vals);
209 } 209 }
210 210
211 // ============================================================================= 211 // =============================================================================
212 // ----------------------------------------------------------------------------- 212 //
213 void Matrix::puts() const 213 void Matrix::puts() const
214 { 214 {
215 for (int i = 0; i < 3; ++i) 215 for (int i = 0; i < 3; ++i)
216 { 216 {
217 for (int j = 0; j < 3; ++j) 217 for (int j = 0; j < 3; ++j)
220 log ("\n"); 220 log ("\n");
221 } 221 }
222 } 222 }
223 223
224 // ============================================================================= 224 // =============================================================================
225 // ----------------------------------------------------------------------------- 225 //
226 QString Matrix::toString() const 226 QString Matrix::toString() const
227 { 227 {
228 QString val; 228 QString val;
229 229
230 for (int i = 0; i < 9; ++i) 230 for (int i = 0; i < 9; ++i)
237 237
238 return val; 238 return val;
239 } 239 }
240 240
241 // ============================================================================= 241 // =============================================================================
242 // ----------------------------------------------------------------------------- 242 //
243 void Matrix::zero() 243 void Matrix::zero()
244 { 244 {
245 memset (&m_vals[0], 0, sizeof m_vals); 245 memset (&m_vals[0], 0, sizeof m_vals);
246 } 246 }
247 247
248 // ============================================================================= 248 // =============================================================================
249 // ----------------------------------------------------------------------------- 249 //
250 Matrix Matrix::mult (const Matrix& other) const 250 Matrix Matrix::mult (const Matrix& other) const
251 { 251 {
252 Matrix val; 252 Matrix val;
253 val.zero(); 253 val.zero();
254 254
259 259
260 return val; 260 return val;
261 } 261 }
262 262
263 // ============================================================================= 263 // =============================================================================
264 // ----------------------------------------------------------------------------- 264 //
265 Matrix& Matrix::operator= (const Matrix& other) 265 Matrix& Matrix::operator= (const Matrix& other)
266 { 266 {
267 memcpy (&m_vals[0], &other.m_vals[0], sizeof m_vals); 267 memcpy (&m_vals[0], &other.m_vals[0], sizeof m_vals);
268 return *this; 268 return *this;
269 } 269 }
270 270
271 // ============================================================================= 271 // =============================================================================
272 // ----------------------------------------------------------------------------- 272 //
273 double Matrix::getDeterminant() const 273 double Matrix::getDeterminant() const
274 { 274 {
275 return (val (0) * val (4) * val (8)) + 275 return (val (0) * val (4) * val (8)) +
276 (val (1) * val (5) * val (6)) + 276 (val (1) * val (5) * val (6)) +
277 (val (2) * val (3) * val (7)) - 277 (val (2) * val (3) * val (7)) -
279 (val (1) * val (3) * val (8)) - 279 (val (1) * val (3) * val (8)) -
280 (val (0) * val (5) * val (7)); 280 (val (0) * val (5) * val (7));
281 } 281 }
282 282
283 // ============================================================================= 283 // =============================================================================
284 // ----------------------------------------------------------------------------- 284 //
285 bool Matrix::operator== (const Matrix& other) const 285 bool Matrix::operator== (const Matrix& other) const
286 { 286 {
287 for (int i = 0; i < 9; ++i) 287 for (int i = 0; i < 9; ++i)
288 if (val (i) != other[i]) 288 if (val (i) != other[i])
289 return false; 289 return false;
290 290
291 return true; 291 return true;
292 } 292 }
293 293
294 // ============================================================================= 294 // =============================================================================
295 // ----------------------------------------------------------------------------- 295 //
296 LDBoundingBox::LDBoundingBox() 296 LDBoundingBox::LDBoundingBox()
297 { 297 {
298 reset(); 298 reset();
299 } 299 }
300 300
301 // ============================================================================= 301 // =============================================================================
302 // ----------------------------------------------------------------------------- 302 //
303 void LDBoundingBox::calculate() 303 void LDBoundingBox::calculate()
304 { 304 {
305 reset(); 305 reset();
306 306
307 if (!getCurrentDocument()) 307 if (!getCurrentDocument())
310 for (LDObject* obj : getCurrentDocument()->getObjects()) 310 for (LDObject* obj : getCurrentDocument()->getObjects())
311 calcObject (obj); 311 calcObject (obj);
312 } 312 }
313 313
314 // ============================================================================= 314 // =============================================================================
315 // ----------------------------------------------------------------------------- 315 //
316 void LDBoundingBox::calcObject (LDObject* obj) 316 void LDBoundingBox::calcObject (LDObject* obj)
317 { 317 {
318 switch (obj->type()) 318 switch (obj->type())
319 { 319 {
320 case LDObject::ELine: 320 case LDObject::ELine:
343 break; 343 break;
344 } 344 }
345 } 345 }
346 346
347 // ============================================================================= 347 // =============================================================================
348 // ----------------------------------------------------------------------------- 348 //
349 LDBoundingBox& LDBoundingBox::operator<< (const Vertex& v) 349 LDBoundingBox& LDBoundingBox::operator<< (const Vertex& v)
350 { 350 {
351 calcVertex (v); 351 calcVertex (v);
352 return *this; 352 return *this;
353 } 353 }
354 354
355 // ============================================================================= 355 // =============================================================================
356 // ----------------------------------------------------------------------------- 356 //
357 LDBoundingBox& LDBoundingBox::operator<< (LDObject* obj) 357 LDBoundingBox& LDBoundingBox::operator<< (LDObject* obj)
358 { 358 {
359 calcObject (obj); 359 calcObject (obj);
360 return *this; 360 return *this;
361 } 361 }
362 362
363 // ============================================================================= 363 // =============================================================================
364 // ----------------------------------------------------------------------------- 364 //
365 void LDBoundingBox::calcVertex (const Vertex& v) 365 void LDBoundingBox::calcVertex (const Vertex& v)
366 { 366 {
367 for_axes (ax) 367 for_axes (ax)
368 { 368 {
369 m_Vertex0[ax] = min (v[ax], m_Vertex0[ax]); 369 m_Vertex0[ax] = min (v[ax], m_Vertex0[ax]);
372 372
373 setEmpty (false); 373 setEmpty (false);
374 } 374 }
375 375
376 // ============================================================================= 376 // =============================================================================
377 // ----------------------------------------------------------------------------- 377 //
378 void LDBoundingBox::reset() 378 void LDBoundingBox::reset()
379 { 379 {
380 m_Vertex0[X] = m_Vertex0[Y] = m_Vertex0[Z] = 10000.0; 380 m_Vertex0[X] = m_Vertex0[Y] = m_Vertex0[Z] = 10000.0;
381 m_Vertex1[X] = m_Vertex1[Y] = m_Vertex1[Z] = -10000.0; 381 m_Vertex1[X] = m_Vertex1[Y] = m_Vertex1[Z] = -10000.0;
382 setEmpty (true); 382 setEmpty (true);
383 } 383 }
384 384
385 // ============================================================================= 385 // =============================================================================
386 // ----------------------------------------------------------------------------- 386 //
387 double LDBoundingBox::size() const 387 double LDBoundingBox::size() const
388 { 388 {
389 double xscale = (m_Vertex0[X] - m_Vertex1[X]); 389 double xscale = (m_Vertex0[X] - m_Vertex1[X]);
390 double yscale = (m_Vertex0[Y] - m_Vertex1[Y]); 390 double yscale = (m_Vertex0[Y] - m_Vertex1[Y]);
391 double zscale = (m_Vertex0[Z] - m_Vertex1[Z]); 391 double zscale = (m_Vertex0[Z] - m_Vertex1[Z]);
404 404
405 return 1.0f; 405 return 1.0f;
406 } 406 }
407 407
408 // ============================================================================= 408 // =============================================================================
409 // ----------------------------------------------------------------------------- 409 //
410 Vertex LDBoundingBox::center() const 410 Vertex LDBoundingBox::center() const
411 { 411 {
412 return Vertex ( 412 return Vertex (
413 (m_Vertex0[X] + m_Vertex1[X]) / 2, 413 (m_Vertex0[X] + m_Vertex1[X]) / 2,
414 (m_Vertex0[Y] + m_Vertex1[Y]) / 2, 414 (m_Vertex0[Y] + m_Vertex1[Y]) / 2,

Mercurial Repository: ldforge

mercurial