Mercurial > ldforge / file comparison

comparison: src/types.cc

src/types.cc

changeset 604
01bdac75994a
parent 603
47e7773c7841
child 606
3dd6f343ec06
equal deleted inserted replaced
603:47e7773c7841 604:01bdac75994a
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)
77 mid[ax] = (m_coords[ax] + other[ax]) / 2; 77 mid[ax] = (m_coords[ax] + other[ax]) / 2;
78 78
79 return mid; 79 return mid;
80 } 80 }
81 81
82 // ============================================================================= 82 // =============================================================================
83 // ----------------------------------------------------------------------------- 83 // -----------------------------------------------------------------------------
84 str vertex::stringRep (bool mangled) const 84 str Vertex::stringRep (bool mangled) const
85 { 85 {
86 str fmtstr = "%1 %2 %3"; 86 str fmtstr = "%1 %2 %3";
87 87
88 if (mangled) 88 if (mangled)
89 fmtstr = "(%1, %2, %3)"; 89 fmtstr = "(%1, %2, %3)";
91 return fmt (fmtstr, coord (X), coord (Y), coord (Z)); 91 return fmt (fmtstr, coord (X), coord (Y), coord (Z));
92 } 92 }
93 93
94 // ============================================================================= 94 // =============================================================================
95 // ----------------------------------------------------------------------------- 95 // -----------------------------------------------------------------------------
96 void vertex::transform (matrix matr, vertex pos) 96 void Vertex::transform (Matrix matr, 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];
101 101
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 double& vertex::operator[] (const Axis ax) 123 double& Vertex::operator[] (const Axis ax)
124 { 124 {
125 return coord ( (int) ax); 125 return coord ( (int) ax);
126 } 126 }
127 127
128 const double& vertex::operator[] (const Axis ax) const 128 const double& Vertex::operator[] (const Axis ax) const
129 { 129 {
130 return coord ( (int) ax); 130 return coord ( (int) ax);
131 } 131 }
132 132
133 double& vertex::operator[] (const int ax) 133 double& Vertex::operator[] (const int ax)
134 { 134 {
135 return coord (ax); 135 return coord (ax);
136 } 136 }
137 137
138 const double& vertex::operator[] (const int ax) const 138 const double& Vertex::operator[] (const int ax) const
139 { 139 {
140 return coord (ax); 140 return coord (ax);
141 } 141 }
142 142
143 // ============================================================================= 143 // =============================================================================
144 // ----------------------------------------------------------------------------- 144 // -----------------------------------------------------------------------------
145 bool vertex::operator== (const vertex& other) const 145 bool Vertex::operator== (const Vertex& other) const
146 { 146 {
147 return coord (X) == other[X] && 147 return coord (X) == other[X] &&
148 coord (Y) == other[Y] && 148 coord (Y) == other[Y] &&
149 coord (Z) == other[Z]; 149 coord (Z) == other[Z];
150 } 150 }
151 151
152 // ============================================================================= 152 // =============================================================================
153 // ----------------------------------------------------------------------------- 153 // -----------------------------------------------------------------------------
154 vertex& vertex::operator/= (const double d) 154 Vertex& Vertex::operator/= (const double d)
155 { 155 {
156 for_axes (ax) 156 for_axes (ax)
157 m_coords[ax] /= d; 157 m_coords[ax] /= d;
158 158
159 return *this; 159 return *this;
160 } 160 }
161 161
162 // ============================================================================= 162 // =============================================================================
163 // ----------------------------------------------------------------------------- 163 // -----------------------------------------------------------------------------
164 vertex vertex::operator/ (const double d) const 164 Vertex Vertex::operator/ (const double d) const
165 { 165 {
166 vertex other (*this); 166 Vertex other (*this);
167 return other /= d; 167 return other /= d;
168 } 168 }
169 169
170 // ============================================================================= 170 // =============================================================================
171 // ----------------------------------------------------------------------------- 171 // -----------------------------------------------------------------------------
172 vertex& vertex::operator+= (const vertex& other) 172 Vertex& Vertex::operator+= (const Vertex& other)
173 { 173 {
174 move (other); 174 move (other);
175 return *this; 175 return *this;
176 } 176 }
177 177
178 // ============================================================================= 178 // =============================================================================
179 // ----------------------------------------------------------------------------- 179 // -----------------------------------------------------------------------------
180 vertex vertex::operator+ (const vertex& other) const 180 Vertex Vertex::operator+ (const Vertex& other) const
181 { 181 {
182 vertex newvert (*this); 182 Vertex newvert (*this);
183 newvert.move (other); 183 newvert.move (other);
184 return newvert; 184 return newvert;
185 } 185 }
186 186
187 // ============================================================================= 187 // =============================================================================
188 // ----------------------------------------------------------------------------- 188 // -----------------------------------------------------------------------------
189 int vertex::operator< (const vertex& other) const 189 int Vertex::operator< (const Vertex& other) const
190 { 190 {
191 if (operator== (other)) 191 if (operator== (other))
192 return false; 192 return false;
193 193
194 if (coord (X) < other[X]) 194 if (coord (X) < other[X])
206 return coord (Z) < other[Z]; 206 return coord (Z) < other[Z];
207 } 207 }
208 208
209 // ============================================================================= 209 // =============================================================================
210 // ----------------------------------------------------------------------------- 210 // -----------------------------------------------------------------------------
211 matrix::matrix (double vals[]) 211 Matrix::Matrix (double vals[])
212 { 212 {
213 for (int i = 0; i < 9; ++i) 213 for (int i = 0; i < 9; ++i)
214 m_vals[i] = vals[i]; 214 m_vals[i] = vals[i];
215 } 215 }
216 216
217 // ============================================================================= 217 // =============================================================================
218 // ----------------------------------------------------------------------------- 218 // -----------------------------------------------------------------------------
219 matrix::matrix (double fillval) 219 Matrix::Matrix (double fillval)
220 { 220 {
221 for (int i = 0; i < 9; ++i) 221 for (int i = 0; i < 9; ++i)
222 m_vals[i] = fillval; 222 m_vals[i] = fillval;
223 } 223 }
224 224
225 // ============================================================================= 225 // =============================================================================
226 // ----------------------------------------------------------------------------- 226 // -----------------------------------------------------------------------------
227 matrix::matrix (initlist<double> vals) 227 Matrix::Matrix (initlist<double> vals)
228 { 228 {
229 assert (vals.size() == 9); 229 assert (vals.size() == 9);
230 memcpy (&m_vals[0], & (*vals.begin()), sizeof m_vals); 230 memcpy (&m_vals[0], & (*vals.begin()), sizeof m_vals);
231 } 231 }
232 232
233 // ============================================================================= 233 // =============================================================================
234 // ----------------------------------------------------------------------------- 234 // -----------------------------------------------------------------------------
235 void matrix::puts() const 235 void Matrix::puts() const
236 { 236 {
237 for (int i = 0; i < 3; ++i) 237 for (int i = 0; i < 3; ++i)
238 { 238 {
239 for (int j = 0; j < 3; ++j) 239 for (int j = 0; j < 3; ++j)
240 log ("%1\t", m_vals[ (i * 3) + j]); 240 log ("%1\t", m_vals[ (i * 3) + j]);
243 } 243 }
244 } 244 }
245 245
246 // ============================================================================= 246 // =============================================================================
247 // ----------------------------------------------------------------------------- 247 // -----------------------------------------------------------------------------
248 str matrix::stringRep() const 248 str Matrix::stringRep() const
249 { 249 {
250 str val; 250 str val;
251 251
252 for (int i = 0; i < 9; ++i) 252 for (int i = 0; i < 9; ++i)
253 { 253 {
260 return val; 260 return val;
261 } 261 }
262 262
263 // ============================================================================= 263 // =============================================================================
264 // ----------------------------------------------------------------------------- 264 // -----------------------------------------------------------------------------
265 void matrix::zero() 265 void Matrix::zero()
266 { 266 {
267 memset (&m_vals[0], 0, sizeof m_vals); 267 memset (&m_vals[0], 0, sizeof m_vals);
268 } 268 }
269 269
270 // ============================================================================= 270 // =============================================================================
271 // ----------------------------------------------------------------------------- 271 // -----------------------------------------------------------------------------
272 matrix matrix::mult (matrix other) const 272 Matrix Matrix::mult (Matrix other) const
273 { 273 {
274 matrix val; 274 Matrix val;
275 val.zero(); 275 val.zero();
276 276
277 for (int i = 0; i < 3; ++i) 277 for (int i = 0; i < 3; ++i)
278 for (int j = 0; j < 3; ++j) 278 for (int j = 0; j < 3; ++j)
279 for (int k = 0; k < 3; ++k) 279 for (int k = 0; k < 3; ++k)
282 return val; 282 return val;
283 } 283 }
284 284
285 // ============================================================================= 285 // =============================================================================
286 // ----------------------------------------------------------------------------- 286 // -----------------------------------------------------------------------------
287 matrix& matrix::operator= (matrix other) 287 Matrix& Matrix::operator= (Matrix other)
288 { 288 {
289 memcpy (&m_vals[0], &other.m_vals[0], sizeof m_vals); 289 memcpy (&m_vals[0], &other.m_vals[0], sizeof m_vals);
290 return *this; 290 return *this;
291 } 291 }
292 292
293 // ============================================================================= 293 // =============================================================================
294 // ----------------------------------------------------------------------------- 294 // -----------------------------------------------------------------------------
295 double matrix::getDeterminant() const 295 double Matrix::getDeterminant() const
296 { 296 {
297 return (val (0) * val (4) * val (8)) + 297 return (val (0) * val (4) * val (8)) +
298 (val (1) * val (5) * val (6)) + 298 (val (1) * val (5) * val (6)) +
299 (val (2) * val (3) * val (7)) - 299 (val (2) * val (3) * val (7)) -
300 (val (2) * val (4) * val (6)) - 300 (val (2) * val (4) * val (6)) -
302 (val (0) * val (5) * val (7)); 302 (val (0) * val (5) * val (7));
303 } 303 }
304 304
305 // ============================================================================= 305 // =============================================================================
306 // ----------------------------------------------------------------------------- 306 // -----------------------------------------------------------------------------
307 bool matrix::operator== (const matrix& other) const 307 bool Matrix::operator== (const Matrix& other) const
308 { 308 {
309 for (int i = 0; i < 9; ++i) 309 for (int i = 0; i < 9; ++i)
310 if (val (i) != other[i]) 310 if (val (i) != other[i])
311 return false; 311 return false;
312 312
343 StringFormatArg::StringFormatArg (const double& v) 343 StringFormatArg::StringFormatArg (const double& v)
344 { 344 {
345 m_val = str::number (v); 345 m_val = str::number (v);
346 } 346 }
347 347
348 StringFormatArg::StringFormatArg (const vertex& v) 348 StringFormatArg::StringFormatArg (const Vertex& v)
349 { 349 {
350 m_val = v.stringRep (false); 350 m_val = v.stringRep (false);
351 } 351 }
352 352
353 StringFormatArg::StringFormatArg (const matrix& v) 353 StringFormatArg::StringFormatArg (const Matrix& v)
354 { 354 {
355 m_val = v.stringRep(); 355 m_val = v.stringRep();
356 } 356 }
357 357
358 StringFormatArg::StringFormatArg (const char* v) 358 StringFormatArg::StringFormatArg (const char* v)
588 // ----------------------------------------------------------------------------- 588 // -----------------------------------------------------------------------------
589 void LDBoundingBox::calcObject (LDObject* obj) 589 void LDBoundingBox::calcObject (LDObject* obj)
590 { 590 {
591 switch (obj->getType()) 591 switch (obj->getType())
592 { 592 {
593 case LDObject::Line: 593 case LDObject::ELine:
594 case LDObject::Triangle: 594 case LDObject::ETriangle:
595 case LDObject::Quad: 595 case LDObject::EQuad:
596 case LDObject::CondLine: 596 case LDObject::ECondLine:
597 { 597 {
598 for (int i = 0; i < obj->vertices(); ++i) 598 for (int i = 0; i < obj->vertices(); ++i)
599 calcVertex (obj->getVertex (i)); 599 calcVertex (obj->getVertex (i));
600 } break; 600 } break;
601 601
602 case LDObject::Subfile: 602 case LDObject::ESubfile:
603 { 603 {
604 LDSubfile* ref = static_cast<LDSubfile*> (obj); 604 LDSubfile* ref = static_cast<LDSubfile*> (obj);
605 QList<LDObject*> objs = ref->inlineContents (LDSubfile::DeepCacheInline); 605 QList<LDObject*> objs = ref->inlineContents (LDSubfile::DeepCacheInline);
606 606
607 for (LDObject * obj : objs) 607 for (LDObject * obj : objs)
617 } 617 }
618 } 618 }
619 619
620 // ============================================================================= 620 // =============================================================================
621 // ----------------------------------------------------------------------------- 621 // -----------------------------------------------------------------------------
622 LDBoundingBox& LDBoundingBox::operator<< (const vertex& v) 622 LDBoundingBox& LDBoundingBox::operator<< (const Vertex& v)
623 { 623 {
624 calcVertex (v); 624 calcVertex (v);
625 return *this; 625 return *this;
626 } 626 }
627 627
633 return *this; 633 return *this;
634 } 634 }
635 635
636 // ============================================================================= 636 // =============================================================================
637 // ----------------------------------------------------------------------------- 637 // -----------------------------------------------------------------------------
638 void LDBoundingBox::calcVertex (const vertex& v) 638 void LDBoundingBox::calcVertex (const Vertex& v)
639 { 639 {
640 for_axes (ax) 640 for_axes (ax)
641 { 641 {
642 if (v[ax] < m_Vertex0[ax]) 642 if (v[ax] < m_Vertex0[ax])
643 m_Vertex0[ax] = v[ax]; 643 m_Vertex0[ax] = v[ax];
682 return 1.0f; 682 return 1.0f;
683 } 683 }
684 684
685 // ============================================================================= 685 // =============================================================================
686 // ----------------------------------------------------------------------------- 686 // -----------------------------------------------------------------------------
687 vertex LDBoundingBox::center() const 687 Vertex LDBoundingBox::center() const
688 { 688 {
689 return vertex ( 689 return Vertex (
690 (m_Vertex0[X] + m_Vertex1[X]) / 2, 690 (m_Vertex0[X] + m_Vertex1[X]) / 2,
691 (m_Vertex0[Y] + m_Vertex1[Y]) / 2, 691 (m_Vertex0[Y] + m_Vertex1[Y]) / 2,
692 (m_Vertex0[Z] + m_Vertex1[Z]) / 2); 692 (m_Vertex0[Z] + m_Vertex1[Z]) / 2);
693 } 693 }

Mercurial Repository: ldforge

mercurial