1 #include <mystdlib.h>
2 #include <myadt.hpp>
3
4 #include <linalg.hpp>
5 #include <stlgeom.hpp>
6
7 #include <meshing.hpp>
8 #ifndef NOTCL
9 #include <visual.hpp>
10 #endif
11
12 namespace netgen
13 {
14
15 /*
16 //mmm
17 #include "stlgeom/modeller.hpp"
18 */
19
20 /* *********************** Draw STL Geometry **************** */
21
22 extern STLGeometry * stlgeometry;
23 extern AutoPtr<Mesh> mesh;
24
25
26 #ifdef OPENGL
27
28 // #include "../../ngtcltk/mvdraw.hpp"
29
30
VisualSceneSTLMeshing()31 VisualSceneSTLMeshing :: VisualSceneSTLMeshing ()
32 : VisualScene()
33 {
34 selecttrig = 0;
35 nodeofseltrig = 1;
36 stlgeometry->SetSelectTrig(selecttrig);
37 stlgeometry->SetNodeOfSelTrig(nodeofseltrig);
38 }
39
~VisualSceneSTLMeshing()40 VisualSceneSTLMeshing :: ~VisualSceneSTLMeshing ()
41 {
42 ;
43 }
44
DrawScene()45 void VisualSceneSTLMeshing :: DrawScene ()
46 {
47 int i, j, k;
48
49 if (changeval != stlgeometry->GetNT())
50 BuildScene();
51 changeval = stlgeometry->GetNT();
52
53 int colormeshsize = vispar.colormeshsize;
54
55 double hmin = 0.0, hmax = 1.0;
56
57 if (colormeshsize)
58 {
59 hmax = -1E50;
60 hmin = +1E50;
61 double ms;
62
63 for (i = 1; i <= stlgeometry->GetNP(); i++)
64 {
65 ms = mesh->GetH (stlgeometry->GetPoint(i));
66 hmin = min2(hmin,ms);
67 hmax = max2(hmax,ms);
68 }
69
70 //hmax = mparam.maxh;
71 //hmin = mesh->GetMinH (stlgeometry->GetBoundingBox().PMin(),
72 // stlgeometry->GetBoundingBox().PMax());
73
74 if (hmin == 0) hmin = 0.1 * hmax;
75 //hmax *= 1.1;
76 }
77
78
79
80 glClearColor(backcolor, backcolor, backcolor, 1.0);
81 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
82
83
84 SetLight();
85
86 glPushMatrix();
87 glMultMatrixf (transformationmat);
88
89 SetClippingPlane ();
90
91 glShadeModel (GL_SMOOTH);
92 glDisable (GL_COLOR_MATERIAL);
93 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
94
95 glEnable (GL_BLEND);
96 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
97
98 float mat_spec_col[] = { 1, 1, 1, 1 };
99 glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, mat_spec_col);
100
101 double shine = vispar.shininess;
102 // double transp = vispar.transp;
103
104 glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shine);
105 glLogicOp (GL_COPY);
106
107 float mat_colred[] = { 0.9f, 0.0f, 0.0f, 1.0f };
108 float mat_colgreen[] = { 0.0f, 0.9f, 0.0f, 1.0f };
109 float mat_colblue[] = { 0.1f, 0.1f, 1.0f, 1.0f };
110
111 float mat_colbluegreen[] = { 0.1f, 0.5f, 0.9f, 1.0f };
112 // float mat_colpink[] = { 1.0f, 0.1f, 0.5f, 1.0f };
113 float mat_colviolet[] = { 1.0f, 0.1f, 1.0f, 1.0f };
114 float mat_colbrown[] = { 0.8f, 0.6f, 0.1f, 1.0f };
115 // float mat_colorange[] = { 0.9f, 0.7f, 0.1f, 1.0f };
116 // float mat_colturquis[] = { 0.0f, 1.0f, 0.8f, 1.0f };
117
118 float mat_colgrey[] = { 0.3f, 0.3f, 0.3f, 1.0f };
119
120 float mat_collred[] = { 1.0f, 0.5f, 0.5f, 1.0f };
121 float mat_collgreen[] = { 0.2f, 1.9f, 0.2f, 1.0f };
122 float mat_collbrown[] = { 1.0f, 0.8f, 0.3f, 1.0f };
123
124 float mat_collgrey[] = { 0.8f, 0.8f, 0.8f, 1.0f };
125 // float mat_colmgrey[] = { 0.4f, 0.4f, 0.4f, 1.0f };
126
127 float mat_colstlbody[] = { 0.0f, 0.0f, 0.8f, 1.0f };
128 float mat_colseltrig[] = { 0.7f, 0.7f, 0.3f, 1.0f };
129 float mat_colseledge[] = { 0.7f, 0.7f, 1.0f, 1.0f };
130
131 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colblue);
132
133 float pgoff = 0.5f;
134
135 glPolygonOffset (pgoff*1, pgoff*1);
136 glEnable (GL_POLYGON_OFFSET_FILL);
137
138 glEnable (GL_NORMALIZE);
139
140 /*
141 {
142 //mmm
143 //test modeller
144 Modeller model;
145
146 //MoZylinder z1(Point3d(0,0,0),Vec3d(100,0,0),20,0.01);
147 //model.Add(&z1);
148 //MoZylinder z2(Point3d(50,50,0),Vec3d(0,-100,0),20,0.01);
149 //model.Add(&z2);
150
151 MoZylinder z1(Point3d(0,0,0),Vec3d(100,0,0),20,0.01);
152 MoZylinder z2(Point3d(50,50,0),Vec3d(0,-100,0),20,0.01);
153 MoCombine cb1(&z1,&z2);
154 model.Add(&cb1);
155
156 Array<MoTriangle> trigs;
157 model.GetTriangles(trigs);
158 int i, k;
159 glBegin (GL_TRIANGLES);
160 for (i = 1; i <= trigs.Size(); i++)
161 {
162 const MoTriangle & tria = trigs.Get(i);
163 glNormal3f (tria.normal.X(),
164 tria.normal.Y(),
165 tria.normal.Z());
166
167 for (k = 0; k < 3; k++)
168 {
169 glVertex3f (tria.pts[k].X(),
170 tria.pts[k].Y(),
171 tria.pts[k].Z());
172 }
173 }
174 glEnd ();
175
176
177 }
178
179 */
180
181
182
183
184 if (!stlgeometry->trigsconverted)
185 {
186 glBegin (GL_TRIANGLES);
187 for (j = 1; j <= stlgeometry -> GetNT(); j++)
188 {
189 /*
190 if (j % 10 == seltria)
191 glMaterialfv (GL_FRONT_AND_BACK,
192 GL_AMBIENT_AND_DIFFUSE, mat_colred);
193 */
194
195 const Vec3d & n = stlgeometry->GetTriangle(j).Normal();
196 glNormal3f (n.X(), n.Y(), n.Z());
197 /*
198 const STLReadTriangle & tria = stlgeometry -> GetReadTriangle(j);
199 glNormal3f (tria.normal.X(),
200 tria.normal.Y(),
201 tria.normal.Z());
202 */
203
204
205 for (k = 1; k <= 3; k++)
206 {
207 const Point3d & tp = stlgeometry->GetPoint(stlgeometry->GetTriangle(j).PNum(k));
208 glVertex3f (tp.X(), tp.Y(), tp.Z());
209
210 }
211 /*
212 if (j%10 == seltria)
213 glMaterialfv (GL_FRONT_AND_BACK,
214 GL_AMBIENT_AND_DIFFUSE, mat_colblue);
215 */
216 }
217 glEnd ();
218
219 glDisable (GL_POLYGON_OFFSET_FILL);
220
221 int showtrias = vispar.stlshowtrias;
222
223 if (showtrias)
224 {
225 float mat_coll[] = { 0.2f, 0.2f, 0.2f, 1.f };
226 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_coll);
227 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
228
229 glEnable (GL_NORMALIZE);
230
231 glBegin (GL_TRIANGLES);
232 for (j = 1; j <= stlgeometry -> GetNT(); j++)
233 {
234 const Vec3d & n = stlgeometry->GetTriangle(j).Normal();
235 glNormal3f (n.X(), n.Y(), n.Z());
236 /*
237 const STLReadTriangle & tria = stlgeometry -> GetReadTriangle(j);
238 glNormal3f (tria.normal.X(),
239 tria.normal.Y(),
240 tria.normal.Z());
241 */
242
243 for (k = 1; k <= 3; k++)
244 {
245 const Point3d & tp =
246 stlgeometry->GetPoint(stlgeometry->GetTriangle(j).PNum(k));
247 glVertex3f (tp.X(), tp.Y(), tp.Z());
248
249 }
250
251 /*
252 for (k = 0; k < 3; k++)
253 {
254 glVertex3f (tria.pts[k].X(),
255 tria.pts[k].Y(),
256 tria.pts[k].Z());
257 }
258 */
259 }
260 glEnd ();
261 }
262 }
263 else
264 {
265 int showfilledtrias = vispar.stlshowfilledtrias;
266
267 //(*mycout) << "in " << showfilledtrias << ", NT=" << stlgeometry -> GetNT() << endl;
268
269 int chartnumber;
270 if (vispar.stlshowmarktrias)
271 chartnumber = vispar.stlchartnumber + vispar.stlchartnumberoffset;
272 else
273 chartnumber = stlgeometry->GetMeshChartNr();
274
275 if (showfilledtrias)
276 {
277 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
278 if (colormeshsize)
279 glEnable (GL_COLOR_MATERIAL);
280
281 glPolygonOffset (pgoff*4, pgoff*4);
282 glEnable (GL_POLYGON_OFFSET_FILL);
283 glEnable (GL_NORMALIZE);
284
285
286 glBegin (GL_TRIANGLES);
287
288 int selt = stlgeometry -> GetSelectTrig();
289 if (stldoctor.selectmode != 0)
290 {selt = 0; } //do not show selected triangle!!!!
291
292 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colstlbody);
293
294 for (j = 1; j <= stlgeometry -> GetNT(); j++)
295 {
296 if (stldoctor.showvicinity && !stlgeometry->Vicinity(j)) {continue;}
297
298 if (j == selt)
299 {
300 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colseltrig);
301 }
302 else if (j == selt+1)
303 {
304 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colstlbody);
305 }
306
307 const STLTriangle& st = stlgeometry -> GetTriangle(j);
308
309 const Vec3d & n = stlgeometry->GetTriangle(j).Normal();
310 glNormal3f (n.X(), n.Y(), n.Z());
311
312 /*
313 const STLReadTriangle& tria = stlgeometry -> GetReadTriangle(j);
314 glNormal3f (tria.normal.X(),
315 tria.normal.Y(),
316 tria.normal.Z());
317 */
318 for (k = 0; k < 3; k++)
319 {
320 const Point3d & p = stlgeometry->GetPoint(st[k]);
321 if (colormeshsize)
322 {
323 SetOpenGlColor (mesh->GetH (p), hmin, hmax, 1);
324 }
325
326 glVertex3f (p.X(), p.Y(), p.Z());
327 }
328 }
329
330 glEnd ();
331 }
332
333 int foundseltrig = stlgeometry -> GetSelectTrig();
334 if (foundseltrig == 0 || foundseltrig > stlgeometry->GetNT() ||
335 (stldoctor.showvicinity && !stlgeometry->Vicinity(foundseltrig)))
336 {foundseltrig = 0;}
337
338 if (foundseltrig)
339 {
340
341 glPolygonOffset (pgoff*0, 0);
342 glEnable (GL_POLYGON_OFFSET_FILL);
343
344 //glDisable (GL_POLYGON_OFFSET_FILL);
345 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colseledge);
346 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
347
348 glEnable (GL_NORMALIZE);
349
350 if (stldoctor.selectmode == 2)
351 {
352 //point
353 const STLTriangle& st = stlgeometry -> GetTriangle(foundseltrig);
354 const Point3d & p1 = stlgeometry->GetPoint(st[0]);
355 const Point3d & p2 = stlgeometry->GetPoint(st[1]);
356 const Point3d & p3 = stlgeometry->GetPoint(st[2]);
357
358 double cs = (Dist(p1,p2)+Dist(p2,p3)+Dist(p3,p1))/100.;
359
360 const Point3d & p = stlgeometry->GetPoint(st[nodeofseltrig-1]);
361
362 glLineWidth (4);
363 glBegin (GL_LINES);
364 glVertex3f(p.X()+cs, p.Y()+cs, p.Z()+cs);
365 glVertex3f(p.X()-cs, p.Y()-cs, p.Z()-cs);
366
367 glVertex3f(p.X()-cs, p.Y()+cs, p.Z()+cs);
368 glVertex3f(p.X()+cs, p.Y()-cs, p.Z()-cs);
369
370 glVertex3f(p.X()-cs, p.Y()+cs, p.Z()+cs);
371 glVertex3f(p.X()+cs, p.Y()-cs, p.Z()-cs);
372
373 glVertex3f(p.X()+cs, p.Y()-cs, p.Z()+cs);
374 glVertex3f(p.X()-cs, p.Y()+cs, p.Z()-cs);
375
376 glEnd ();
377 glLineWidth (1);
378 }
379 else if (stldoctor.selectmode == 1 ||
380 stldoctor.selectmode == 3 ||
381 stldoctor.selectmode == 4)
382 {
383 //multiedge
384
385 const Array<twoint>& me = stlgeometry->SelectedMultiEdge();
386 if (stlgeometry->GetSelectTrig() > 0 &&
387 stlgeometry->GetSelectTrig() <= stlgeometry->GetNT() &&
388 me.Size())
389 {
390
391 int en = stlgeometry->EdgeDataList().GetEdgeNum(me.Get(1).i1,me.Get(1).i2);
392 int status = stlgeometry->EdgeDataList().Get(en).GetStatus();
393
394 switch (status)
395 {
396 case ED_CONFIRMED:
397 glMaterialfv (GL_FRONT_AND_BACK,
398 GL_AMBIENT_AND_DIFFUSE, mat_collgreen);
399 break;
400 case ED_CANDIDATE:
401 glMaterialfv (GL_FRONT_AND_BACK,
402 GL_AMBIENT_AND_DIFFUSE, mat_collbrown);
403 break;
404 case ED_EXCLUDED:
405 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_collred);
406 break;
407 }
408
409 glLineWidth (2);
410 glBegin (GL_LINES);
411 for (j = 1; j <= me.Size(); j++)
412 {
413 Point3d p1 = stlgeometry->GetPoint(me.Get(j).i1);
414 Point3d p2 = stlgeometry->GetPoint(me.Get(j).i2);
415
416 glVertex3f(p1.X(), p1.Y(), p1.Z());
417 glVertex3f(p2.X(), p2.Y(), p2.Z());
418 }
419 glEnd ();
420 glLineWidth (1);
421 }
422 }
423 }
424
425 int showmarktrias = vispar.stlshowmarktrias || vispar.stlshowactivechart;
426
427 if (stldoctor.showmarkedtrigs)
428 {
429 //(*mycout) << "marked" << endl;
430 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE); //GL_LINE
431 glPolygonOffset (pgoff*1, pgoff*1);
432 glEnable (GL_POLYGON_OFFSET_FILL);
433 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colbluegreen);
434 glEnable (GL_NORMALIZE);
435
436 glBegin (GL_TRIANGLES);
437
438 for (j = 1; j <= stlgeometry -> GetNT(); j++)
439 {
440 if (stldoctor.showvicinity && !stlgeometry->Vicinity(j))
441 {continue;}
442
443 if (!stlgeometry->IsMarkedTrig(j))
444 {continue;}
445
446 const STLTriangle& st = stlgeometry -> GetTriangle(j);
447
448 const Vec3d & n = stlgeometry->GetTriangle(j).Normal();
449 glNormal3f (n.X(), n.Y(), n.Z());
450 /*
451 const STLReadTriangle& tria = stlgeometry -> GetReadTriangle(j);
452 glNormal3f (tria.normal.X(),
453 tria.normal.Y(),
454 tria.normal.Z());
455 */
456 for (k = 0; k < 3; k++)
457 {
458 const Point3d & p = stlgeometry->GetPoint(st[k]);
459 glVertex3f (p.X(), p.Y(), p.Z());
460 }
461 }
462 glEnd ();
463
464 //show OpenSegments on original geometry
465 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colviolet);
466 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
467 glPolygonOffset (pgoff*1, 1);
468
469 glEnable (GL_NORMALIZE);
470
471 glBegin (GL_LINES);
472
473 if (stlgeometry->GetNMarkedSegs())
474 {
475 Point<3> p1,p2;
476 for (j = 1; j <= stlgeometry -> GetNMarkedSegs(); j++)
477 {
478 stlgeometry->GetMarkedSeg(j,p1,p2);
479 glVertex3dv(&p1(0));
480 glVertex3dv(&p2(0));
481 }
482 }
483 glEnd ();
484 }
485
486
487 if (stldoctor.showfaces)
488 {
489 int facenumber = vispar.stlchartnumber + vispar.stlchartnumberoffset;
490
491 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
492 glPolygonOffset (pgoff*3, 3);
493 glEnable (GL_POLYGON_OFFSET_FILL);
494 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_collgrey);
495 glEnable (GL_NORMALIZE);
496
497 glBegin (GL_TRIANGLES);
498
499 for (j = 1; j <= stlgeometry -> GetNT(); j++)
500 {
501 if (stldoctor.showvicinity && !stlgeometry->Vicinity(j))
502 {continue;}
503
504 //(*mycout) << " facenum = " << stlgeometry->GetTriangle(j).GetFaceNum() << " ";
505 if (stlgeometry->GetTriangle(j).GetFaceNum() != facenumber)
506 {continue;}
507
508 const STLTriangle& st = stlgeometry -> GetTriangle(j);
509
510 const Vec3d & n = stlgeometry->GetTriangle(j).Normal();
511 glNormal3f (n.X(), n.Y(), n.Z());
512 /*
513 const STLReadTriangle& tria = stlgeometry -> GetReadTriangle(j);
514 glNormal3f (tria.normal.X(),
515 tria.normal.Y(),
516 tria.normal.Z());
517 */
518 for (k = 0; k < 3; k++)
519 {
520 Point3d p = stlgeometry->GetPoint(st[k]);
521 glVertex3f (p.X(), p.Y(), p.Z());
522 }
523 }
524 glEnd ();
525 }
526
527 if (showmarktrias && stlgeometry->AtlasMade())
528 {
529 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
530 glPolygonOffset (pgoff*3, 3);
531 glEnable (GL_POLYGON_OFFSET_FILL);
532
533 glBegin (GL_TRIANGLES);
534
535 if (chartnumber >= 1 && chartnumber <= stlgeometry->GetNOCharts())
536 {
537 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colbrown);
538 const STLChart& chart = stlgeometry->GetChart(chartnumber);
539 for (j = 1; j <= chart.GetNChartT(); j++)
540 {
541 /*
542 if (j == charttrignumber)
543 {glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colred);}
544 else
545 {glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colbrown);}
546 */
547 const STLTriangle& st = stlgeometry -> GetTriangle(chart.GetChartTrig(j));
548
549
550 const Vec3d & n = stlgeometry->GetTriangle(chart.GetChartTrig(j)).Normal();
551 glNormal3f (n.X(), n.Y(), n.Z());
552 /*
553 const STLReadTriangle& tria = stlgeometry -> GetReadTriangle(chart.GetChartTrig(j));
554 glNormal3f (tria.normal.X(),
555 tria.normal.Y(),
556 tria.normal.Z());
557 */
558 for (k = 0; k < 3; k++)
559 {
560 glVertex3f (stlgeometry->GetPoint(st[k])(0),
561 stlgeometry->GetPoint(st[k])(1),
562 stlgeometry->GetPoint(st[k])(2));
563 }
564 }
565 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colgreen);
566
567 for (j = 1; j <= chart.GetNOuterT(); j++)
568 {
569
570 const STLTriangle& st = stlgeometry -> GetTriangle(chart.GetOuterTrig(j));
571
572 const Vec3d & n = stlgeometry->GetTriangle(chart.GetOuterTrig(j)).Normal();
573 glNormal3f (n.X(), n.Y(), n.Z());
574
575
576 /*
577 const STLReadTriangle& tria = stlgeometry -> GetReadTriangle(chart.GetOuterTrig(j));
578 glNormal3f (tria.normal.X(),
579 tria.normal.Y(),
580 tria.normal.Z());
581 */
582 for (k = 0; k < 3; k++)
583 {
584 glVertex3f (stlgeometry->GetPoint(st[k])(0),
585 stlgeometry->GetPoint(st[k])(1),
586 stlgeometry->GetPoint(st[k])(2));
587 }
588 }
589 }
590 glEnd ();
591 }
592
593 int showtrias = vispar.stlshowtrias;
594
595 if (showtrias)
596 {
597 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colgrey);
598 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
599 glPolygonOffset (pgoff*2, 2);
600 glEnable (GL_POLYGON_OFFSET_FILL);
601 glEnable (GL_NORMALIZE);
602
603 glBegin (GL_TRIANGLES);
604
605 for (j = 1; j <= stlgeometry -> GetNT(); j++)
606 {
607 if (stldoctor.showvicinity && !stlgeometry->Vicinity(j)) {continue;}
608
609 const STLTriangle& st = stlgeometry -> GetTriangle(j);
610
611 const Vec3d & n = stlgeometry->GetTriangle(j).Normal();
612 glNormal3f (n.X(), n.Y(), n.Z());
613 /*
614 const STLReadTriangle& tria = stlgeometry -> GetReadTriangle(j);
615 glNormal3f (tria.normal.X(),
616 tria.normal.Y(),
617 tria.normal.Z());
618 */
619 for (k = 0; k < 3; k++)
620 {
621 glVertex3f (stlgeometry->GetPoint(st[k])(0),
622 stlgeometry->GetPoint(st[k])(1),
623 stlgeometry->GetPoint(st[k])(2));
624 }
625 }
626 glEnd ();
627 }
628
629 int showedges = vispar.stlshowedges;
630
631 if (showedges)
632 {
633 glPolygonOffset (pgoff*1, 1);
634 glEnable (GL_POLYGON_OFFSET_FILL);
635 //glDisable (GL_POLYGON_OFFSET_FILL);
636
637 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colgreen);
638 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
639
640 glEnable (GL_NORMALIZE);
641
642 glBegin (GL_LINES);
643
644 /*
645 if (stldoctor.useexternaledges)
646 {
647 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colorange);
648 for (j = 1; j <= stlgeometry -> NOExternalEdges(); j++)
649 {
650 twoint v = stlgeometry->GetExternalEdge(j);
651 Point3d p1 = stlgeometry->GetPoint(v.i1);
652 Point3d p2 = stlgeometry->GetPoint(v.i2);
653
654 Vec3d n1 = stlgeometry->GetNormal(v.i1);
655 Vec3d n2 = stlgeometry->GetNormal(v.i2);
656
657 glNormal3f(n1.X(), n1.Y(), n1.Z());
658 glVertex3f(p1.X(), p1.Y(), p1.Z());
659 glNormal3f(n2.X(), n2.Y(), n2.Z());
660 glVertex3f(p2.X(), p2.Y(), p2.Z());
661 }
662 }
663 */
664
665
666 if (!stlgeometry->meshlines.Size() || !stldoctor.drawmeshededges)
667 {
668 /*
669 for (j = 1; j <= stlgeometry -> GetNE(); j++)
670 {
671 STLEdge v = stlgeometry->GetEdge(j);
672 Point3d p1 = stlgeometry->GetPoint(v.pts[0]);
673 Point3d p2 = stlgeometry->GetPoint(v.pts[1]);
674
675 Vec3d n1 = stlgeometry->GetNormal(v.pts[0]);
676 Vec3d n2 = stlgeometry->GetNormal(v.pts[1]);
677
678 glNormal3f(n1.X(), n1.Y(), n1.Z());
679 glVertex3f(p1.X(), p1.Y(), p1.Z());
680 glNormal3f(n2.X(), n2.Y(), n2.Z());
681 glVertex3f(p2.X(), p2.Y(), p2.Z());
682 }
683 */
684 const STLEdgeDataList& ed = stlgeometry->EdgeDataList();
685 for (i = 1; i <= ed.Size(); i++)
686 {
687 if (ed.Get(i).GetStatus() != ED_UNDEFINED)
688 {
689 switch (ed.Get(i).GetStatus())
690 {
691 case ED_CONFIRMED:
692 glMaterialfv (GL_FRONT_AND_BACK,
693 GL_AMBIENT_AND_DIFFUSE, mat_colgreen);
694 break;
695 case ED_CANDIDATE:
696 glMaterialfv (GL_FRONT_AND_BACK,
697 GL_AMBIENT_AND_DIFFUSE, mat_colbrown);
698 break;
699 case ED_EXCLUDED:
700 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colred);
701 break;
702 }
703
704 if (ed.Get(i).GetStatus() == ED_EXCLUDED && !stldoctor.showexcluded) continue;
705
706 Point3d p1 = stlgeometry->GetPoint(ed.Get(i).PNum(1));
707 Point3d p2 = stlgeometry->GetPoint(ed.Get(i).PNum(2));
708 glVertex3f(p1.X(), p1.Y(), p1.Z());
709 glVertex3f(p2.X(), p2.Y(), p2.Z());
710 }
711 }
712 }
713
714 /*
715 else
716 if (stlgeometry->meshlines.Size() == 0)
717 {
718 for (j = 1; j <= stlgeometry->GetNLines(); j++)
719 {
720 STLLine* line = stlgeometry->GetLine(j);
721 int pn1, pn2;
722 for (int k = 1; k <= line->NP()-1; k++)
723 {
724 pn1 = line->PNum(k);
725 pn2 = line->PNum(k+1);
726
727 Point3d p1 = stlgeometry->GetPoint(pn1);
728 Point3d p2 = stlgeometry->GetPoint(pn2);
729
730 Vec3d n1 = stlgeometry->GetNormal(pn1);
731 Vec3d n2 = stlgeometry->GetNormal(pn2);
732
733 glNormal3f(n1.X(), n1.Y(), n1.Z());
734 glVertex3f(p1.X(), p1.Y(), p1.Z());
735 glNormal3f(n2.X(), n2.Y(), n2.Z());
736 glVertex3f(p2.X(), p2.Y(), p2.Z());
737 }
738 }
739 }
740 */
741
742 else if (stlgeometry->meshlines.Size() != 0)
743 {
744 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colgreen);
745 for (j = 1; j <= stlgeometry->meshlines.Size(); j++)
746 {
747 STLLine* line = stlgeometry->meshlines.Get(j);
748 int pn1, pn2;
749 for (int k = 1; k <= line->NP()-1; k++)
750 {
751 pn1 = line->PNum(k);
752 pn2 = line->PNum(k+1);
753
754 Point3d p1 = stlgeometry->meshpoints.Get(pn1);
755 Point3d p2 = stlgeometry->meshpoints.Get(pn2);
756
757 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colgreen);
758 glVertex3f(p1.X(), p1.Y(), p1.Z());
759 glVertex3f(p2.X(), p2.Y(), p2.Z());
760
761
762 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colred);
763 double cs = 0.02*Dist(p1,p2);
764 glVertex3f(p1.X()+cs, p1.Y()+cs, p1.Z()+cs);
765 glVertex3f(p1.X()-cs, p1.Y()-cs, p1.Z()-cs);
766 glVertex3f(p2.X()+cs, p2.Y()+cs, p2.Z()+cs);
767 glVertex3f(p2.X()-cs, p2.Y()-cs, p2.Z()-cs);
768
769 glVertex3f(p1.X()-cs, p1.Y()+cs, p1.Z()+cs);
770 glVertex3f(p1.X()+cs, p1.Y()-cs, p1.Z()-cs);
771 glVertex3f(p2.X()-cs, p2.Y()+cs, p2.Z()+cs);
772 glVertex3f(p2.X()+cs, p2.Y()-cs, p2.Z()-cs);
773
774 }
775 }
776 }
777
778
779 glEnd ();
780 }
781
782 if (stldoctor.showedgecornerpoints && stlgeometry->LineEndPointsSet())
783 {
784 glPointSize (5);
785 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colred);
786 glBegin (GL_POINTS);
787 for (i = 1; i <= stlgeometry->GetNP(); i++)
788 {
789 if (stlgeometry->IsLineEndPoint(i))
790 {
791 const Point3d p = stlgeometry->GetPoint(i);
792 glVertex3f (p.X(), p.Y(), p.Z());
793 }
794 }
795 glEnd();
796
797 }
798
799
800 }
801
802
803 glPopMatrix();
804
805 if (vispar.colormeshsize)
806 DrawColorBar (hmin, hmax, 1);
807
808 glFinish();
809 }
810
811
BuildScene(int zoomall)812 void VisualSceneSTLMeshing :: BuildScene (int zoomall)
813 {
814 if (selecttrig && zoomall == 2)
815 center = stlgeometry -> GetPoint ( stlgeometry->GetTriangle(selecttrig).PNum(nodeofseltrig));
816 else
817 center = stlgeometry -> GetBoundingBox().Center();
818
819 rad = stlgeometry -> GetBoundingBox().Diam() / 2;
820
821 CalcTransformationMatrices();
822 }
823
824
825
MouseDblClick(int px,int py)826 void VisualSceneSTLMeshing :: MouseDblClick (int px, int py)
827 {
828 // (*mycout) << "dblclick: " << px << " - " << py << endl;
829
830
831 int i, j, k, hits;
832
833 // select surface triangle by mouse click
834
835 GLuint selbuf[10000];
836 glSelectBuffer (10000, selbuf);
837
838
839 glRenderMode (GL_SELECT);
840
841 GLint viewport[4];
842 glGetIntegerv (GL_VIEWPORT, viewport);
843
844 /*
845 (*mycout) << "viewport = " << viewport[0] << " "
846 << viewport[1] << " " << viewport[2] << " " << viewport[3] << endl;
847 */
848
849 glMatrixMode (GL_PROJECTION);
850 glPushMatrix();
851
852
853 GLdouble projmat[16];
854 glGetDoublev (GL_PROJECTION_MATRIX, projmat);
855
856 glLoadIdentity();
857 gluPickMatrix (px, viewport[3] - py, 1, 1, viewport);
858 glMultMatrixd (projmat);
859
860
861
862 glClearColor(backcolor, backcolor, backcolor, 1.0);
863 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
864
865 glMatrixMode (GL_MODELVIEW);
866
867 glPushMatrix();
868 glMultMatrixf (transformationmat);
869
870
871 glInitNames();
872 glPushName (1);
873
874
875 glEnable (GL_POLYGON_OFFSET_FILL);
876 for (j = 1; j <= stlgeometry -> GetNT(); j++)
877 {
878 if (stldoctor.showvicinity && !stlgeometry->Vicinity(j)) {continue;}
879
880 const STLTriangle& st = stlgeometry -> GetTriangle(j);
881
882 //const STLReadTriangle& tria = stlgeometry -> GetReadTriangle(j);
883 //glNormal3f (tria.normal.X(), tria.normal.Y(), tria.normal.Z());
884
885 if (stldoctor.selectmode == 0)
886 {
887 glLoadName (j);
888 glBegin (GL_TRIANGLES);
889 for (k = 0; k < 3; k++)
890 {
891 Point3d p = stlgeometry->GetPoint(st[k]);
892 glVertex3f (p.X(), p.Y(), p.Z());
893 }
894 glEnd ();
895 }
896 else if (stldoctor.selectmode == 1 || stldoctor.selectmode == 3
897 || stldoctor.selectmode == 4)
898 {
899 Point3d pm = Center(stlgeometry->GetPoint(st[0]),
900 stlgeometry->GetPoint(st[1]),
901 stlgeometry->GetPoint(st[2]));
902
903 for (k = 0; k < 3; k++)
904 {
905 glLoadName (j*3+k-2);
906 glBegin (GL_TRIANGLES);
907
908 Point3d p1 = stlgeometry->GetPoint(st[k]);
909 Point3d p2 = stlgeometry->GetPoint(st[(k+1)%3]);
910 glVertex3f (p1.X(), p1.Y(), p1.Z());
911 glVertex3f (p2.X(), p2.Y(), p2.Z());
912 glVertex3f (pm.X(), pm.Y(), pm.Z());
913
914 glEnd ();
915 }
916 }
917 else
918 {
919 Point3d pm1 = Center(stlgeometry->GetPoint(st[0]),
920 stlgeometry->GetPoint(st[1]));
921 Point3d pm2 = Center(stlgeometry->GetPoint(st[1]),
922 stlgeometry->GetPoint(st[2]));
923 Point3d pm3 = Center(stlgeometry->GetPoint(st[2]),
924 stlgeometry->GetPoint(st[0]));
925
926 Point3d p1 = stlgeometry->GetPoint(st[0]);
927 Point3d p2 = stlgeometry->GetPoint(st[1]);
928 Point3d p3 = stlgeometry->GetPoint(st[2]);
929
930 glLoadName (j*4-3);
931 glBegin (GL_TRIANGLES);
932 glVertex3f (p1.X(), p1.Y(), p1.Z());
933 glVertex3f (pm1.X(), pm1.Y(), pm1.Z());
934 glVertex3f (pm3.X(), pm3.Y(), pm3.Z());
935 glEnd ();
936
937 glLoadName (j*4-2);
938 glBegin (GL_TRIANGLES);
939 glVertex3f (p2.X(), p2.Y(), p2.Z());
940 glVertex3f (pm2.X(), pm2.Y(), pm2.Z());
941 glVertex3f (pm1.X(), pm1.Y(), pm1.Z());
942 glEnd ();
943
944 glLoadName (j*4-1);
945 glBegin (GL_TRIANGLES);
946 glVertex3f (p3.X(), p3.Y(), p3.Z());
947 glVertex3f (pm3.X(), pm3.Y(), pm3.Z());
948 glVertex3f (pm2.X(), pm2.Y(), pm2.Z());
949 glEnd ();
950
951 glLoadName (j*4);
952 glBegin (GL_TRIANGLES);
953 glVertex3f (pm1.X(), pm1.Y(), pm1.Z());
954 glVertex3f (pm2.X(), pm2.Y(), pm2.Z());
955 glVertex3f (pm3.X(), pm3.Y(), pm3.Z());
956 glEnd ();
957 }
958 }
959
960 glPopName();
961
962 glMatrixMode (GL_PROJECTION);
963 glPopMatrix();
964
965 glMatrixMode (GL_MODELVIEW);
966 glPopMatrix();
967
968 glFlush();
969
970
971 hits = glRenderMode (GL_RENDER);
972
973 // (*mycout) << "hits = " << hits << endl;
974
975 //int minrec = -1;
976 int minname = 0;
977 GLuint mindepth = 0;
978 for (i = 0; i < hits; i++)
979 {
980 int curname = selbuf[4*i+3];
981 GLuint curdepth = selbuf[4*i+1];
982
983 /*
984 (*mycout) << selbuf[4*i] << " " << selbuf[4*i+1] << " "
985 << selbuf[4*i+2] << " " << selbuf[4*i+3] << endl;
986 */
987 if (curname &&
988 (curdepth < mindepth || !minname))
989 {
990 //minrec = i;
991 mindepth = curdepth;
992 minname = curname;
993 }
994 }
995
996 if (!minname) {return;}
997
998 if (stldoctor.selectmode == 0)
999 {
1000 int oldtrig = selecttrig;
1001 selecttrig = minname;
1002 if (selecttrig == oldtrig)
1003 nodeofseltrig = (nodeofseltrig % 3) + 1;
1004 else
1005 nodeofseltrig = 1;
1006
1007 stlgeometry->SetSelectTrig(selecttrig);
1008 stlgeometry->SetNodeOfSelTrig(nodeofseltrig);
1009 stlgeometry->PrintSelectInfo();
1010
1011 }
1012 else if (stldoctor.selectmode == 1 || stldoctor.selectmode == 3 || stldoctor.selectmode == 4)
1013 {
1014 selecttrig = (minname-1) / 3 + 1;
1015 nodeofseltrig = minname-selecttrig*3+3;
1016
1017 stlgeometry->SetSelectTrig(selecttrig);
1018 stlgeometry->SetNodeOfSelTrig(nodeofseltrig);
1019 stlgeometry->PrintSelectInfo();
1020
1021 if (stldoctor.selectmode == 1)
1022 {
1023 stlgeometry->BuildSelectedEdge(twoint(stlgeometry->GetTriangle(selecttrig).PNumMod(nodeofseltrig),
1024 stlgeometry->GetTriangle(selecttrig).PNumMod(nodeofseltrig+1)));
1025 }
1026 if (stldoctor.selectmode == 3)
1027 {
1028 stlgeometry->BuildSelectedMultiEdge(twoint(stlgeometry->GetTriangle(selecttrig).PNumMod(nodeofseltrig),
1029 stlgeometry->GetTriangle(selecttrig).PNumMod(nodeofseltrig+1)));
1030 }
1031 else if (stldoctor.selectmode == 4)
1032 {
1033 stlgeometry->BuildSelectedCluster(twoint(stlgeometry->GetTriangle(selecttrig).PNumMod(nodeofseltrig),
1034 stlgeometry->GetTriangle(selecttrig).PNumMod(nodeofseltrig+1)));
1035 }
1036
1037 switch (stldoctor.edgeselectmode)
1038 {
1039 case 1: stlgeometry->STLDoctorUndefinedEdge(); break;
1040 case 2: stlgeometry->STLDoctorConfirmEdge(); break;
1041 case 3: stlgeometry->STLDoctorCandidateEdge(); break;
1042 case 4: stlgeometry->STLDoctorExcludeEdge(); break;
1043 default: break;
1044 }
1045 }
1046 else if (stldoctor.selectmode == 2)
1047 {
1048 selecttrig = (minname-1) / 4 + 1;
1049 nodeofseltrig = minname-selecttrig*4+4;
1050 if (nodeofseltrig == 4) {nodeofseltrig = 1;}
1051
1052 stlgeometry->SetSelectTrig(selecttrig);
1053 stlgeometry->SetNodeOfSelTrig(nodeofseltrig);
1054 stlgeometry->PrintSelectInfo();
1055
1056 }
1057
1058 if (stldoctor.showtouchedtrigchart && stlgeometry->AtlasMade() && stlgeometry->GetSelectTrig())
1059 {
1060 vispar.stlchartnumber = stlgeometry->GetChartNr(stlgeometry->GetSelectTrig());
1061 vispar.stlchartnumberoffset = 0;
1062 }
1063
1064 }
1065
1066
1067
1068
1069 VisualSceneSTLMeshing vsstlmeshing;
1070
1071 #endif
1072
1073
1074
1075
1076 }
1077