0024510: Remove unused local variables
[occt.git] / src / DrawTrSurf / DrawTrSurf.cxx
CommitLineData
b311480e 1// Created on: 1993-08-12
2// Created by: Bruno DUMORTIER
3// Copyright (c) 1993-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
973c2be1 8// This library is free software; you can redistribute it and / or modify it
9// under the terms of the GNU Lesser General Public version 2.1 as published
10// by the Free Software Foundation, with special exception defined in the file
11// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12// distribution for complete text of the license and disclaimer of any warranty.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
7fd59977 16
17#ifdef HAVE_CONFIG_H
18# include <config.h>
19#endif
20
21#ifdef HAVE_IOS
22# include <ios>
23#elif defined(HAVE_IOS_H)
24# include <ios.h>
25#endif
26
27#ifdef HAVE_STRINGS_H
28# include <strings.h>
29#endif
30
31#include <Standard_Stream.hxx>
32
33#include <Draw_Color.hxx>
34#include <DrawTrSurf.ixx>
35#include <DrawTrSurf_Point.hxx>
36#include <DrawTrSurf_BezierSurface.hxx>
37#include <DrawTrSurf_BSplineSurface.hxx>
38#include <DrawTrSurf_BezierCurve.hxx>
39#include <DrawTrSurf_BSplineCurve.hxx>
40#include <DrawTrSurf_BezierCurve2d.hxx>
41#include <DrawTrSurf_BSplineCurve2d.hxx>
42#include <DrawTrSurf_Triangulation.hxx>
43#include <DrawTrSurf_Polygon3D.hxx>
44#include <DrawTrSurf_Polygon2D.hxx>
45#include <Draw_Appli.hxx>
46#include <Draw.hxx>
47
48#include <GeomTools_CurveSet.hxx>
49#include <GeomTools_Curve2dSet.hxx>
50#include <GeomTools_SurfaceSet.hxx>
51
52#include <gp_Pln.hxx>
53#include <gp_Ax2d.hxx>
54#include <gp_Ax2.hxx>
55#include <gp_Trsf2d.hxx>
56#include <Poly.hxx>
445f3267 57#include <TCollection_AsciiString.hxx>
7fd59977 58
59static Draw_Color PntColor(Draw_rouge);
60static Draw_Color CurvColor(Draw_jaune);
61static Draw_Color BoundsColor(Draw_vert);
62static Draw_Color IsosColor(Draw_bleu);
63static Draw_Color PolesColor(Draw_rouge);
64static Draw_Color KnotsColor(Draw_violet);
65
66static Draw_MarkerShape PntShape = Draw_Plus;
67static Draw_MarkerShape KnotsShape = Draw_Losange;
68static Standard_Boolean ShowPoles = Standard_True;
69static Standard_Boolean ShowKnots = Standard_True;
70static Standard_Boolean knotsIsos =Standard_True;
71static Standard_Real Deflection = 0.01;
72static Standard_Integer KnotsSize = 5;
73static Standard_Integer Discret = 30;
74static Standard_Integer DrawMode = 0;
75static Standard_Integer NbUIsos = 10;
76static Standard_Integer NbVIsos = 10;
77
445f3267
S
78static TCollection_AsciiString ColorsHint(
79"The possible colors are: \n\
80 white, red, green, blue, cyan,\n\
81 golden, magenta, brown, orange, pink,\n\
82 salmon, violet, yellow, darkgreen, coral");
83
84static TCollection_AsciiString MarkersHint(
85"The possible markers are: \n\
86 square, diamond, x, plus, circle, circle_zoom");
87
88//=======================================================================
89//function : DrawTrSurf_CurveColor
90//purpose : Sets new color for rendering of curves. Returns the
91// previous one to keep possibility to restore the initial
92// state
93//=======================================================================
94
7fd59977 95Standard_EXPORT Draw_Color DrawTrSurf_CurveColor(const Draw_Color col)
96{
97 Draw_Color c = CurvColor;
98 CurvColor = col;
99 return c;
100}
101
102//=======================================================================
445f3267
S
103//function : DrawTrSurf_PointColor
104//purpose : Sets new color for rendering of points. Returns the
105// previous one to keep possibility to restore the initial
106// state
107//=======================================================================
108
109Standard_EXPORT Draw_Color DrawTrSurf_PointColor(const Draw_Color col)
110{
111 Draw_Color c = PntColor;
112 PntColor = col;
113 return c;
114}
115
116//=======================================================================
117//function : DrawTrSurf_PointMarker
118//purpose : Sets new marker for rendering of points. Returns the
119// previous one to keep possibility to restore the initial
120// state
121//=======================================================================
122
123Standard_EXPORT Draw_MarkerShape DrawTrSurf_PointMarker(const Draw_MarkerShape marker)
124{
125 Draw_MarkerShape prev = PntShape;
126 PntShape = marker;
127 return prev;
128}
129
130//=======================================================================
7fd59977 131//function : GetDrawable
132//purpose :
133//=======================================================================
134static Handle(DrawTrSurf_Drawable) GetDrawable(Standard_CString& Name)
135{
136 Handle(Draw_Drawable3D) D = Draw::Get(Name);
137 Handle(DrawTrSurf_Drawable) Dr;
138 if (!D.IsNull())
139 Dr = Handle(DrawTrSurf_Drawable)::DownCast(D);
140 return Dr;
141}
142
143//=======================================================================
144//function : GetSurface
145//purpose :
146//=======================================================================
147static Handle(DrawTrSurf_Surface) GetSurface(Standard_CString& Name)
148{
149 Handle(Draw_Drawable3D) D = Draw::Get(Name);
150 Handle(DrawTrSurf_Surface) Dr;
151 if (!D.IsNull())
152 Dr = Handle(DrawTrSurf_Surface)::DownCast(D);
153 return Dr;
154}
155
156//=======================================================================
157//function : GetBezierSurface
158//purpose :
159//=======================================================================
160static Handle(DrawTrSurf_BezierSurface) GetBezierSurface(Standard_CString& Name)
161{
162 Handle(Draw_Drawable3D) D = Draw::Get(Name);
163 Handle(DrawTrSurf_BezierSurface) Dr;
164 if (!D.IsNull())
165 Dr = Handle(DrawTrSurf_BezierSurface)::DownCast(D);
166 return Dr;
167}
168
169//=======================================================================
170//function : GetBSplineSurface
171//purpose :
172//=======================================================================
173static Handle(DrawTrSurf_BSplineSurface) GetBSplineSurface(Standard_CString& Name)
174{
175 Handle(Draw_Drawable3D) D = Draw::Get(Name);
176 Handle(DrawTrSurf_BSplineSurface) Dr;
177 if (!D.IsNull())
178 Dr = Handle(DrawTrSurf_BSplineSurface)::DownCast(D);
179 return Dr;
180}
181
7fd59977 182//=======================================================================
183//function : GetBezierCurve
184//purpose :
185//=======================================================================
186static Handle(DrawTrSurf_BezierCurve) GetBezierCurve(Standard_CString& Name)
187{
188 Handle(Draw_Drawable3D) D = Draw::Get(Name);
189 Handle(DrawTrSurf_BezierCurve) Dr;
190 if (!D.IsNull())
191 Dr = Handle(DrawTrSurf_BezierCurve)::DownCast(D);
192 return Dr;
193}
194
195//=======================================================================
196//function : GetBSplineCurve
197//purpose :
198//=======================================================================
199static Handle(DrawTrSurf_BSplineCurve) GetBSplineCurve(Standard_CString& Name)
200{
201 Handle(Draw_Drawable3D) D = Draw::Get(Name);
202 Handle(DrawTrSurf_BSplineCurve) Dr;
203 if (!D.IsNull())
204 Dr = Handle(DrawTrSurf_BSplineCurve)::DownCast(D);
205 return Dr;
206}
207
208//=======================================================================
209//function : GetBezierCurve2d
210//purpose :
211//=======================================================================
212static Handle(DrawTrSurf_BezierCurve2d) GetBezierCurve2d(Standard_CString& Name)
213{
214 Handle(Draw_Drawable3D) D = Draw::Get(Name);
215 Handle(DrawTrSurf_BezierCurve2d) Dr;
216 if (!D.IsNull())
217 Dr = Handle(DrawTrSurf_BezierCurve2d)::DownCast(D);
218 return Dr;
219}
220
221//=======================================================================
222//function : GetBSplineCurve2d
223//purpose :
224//=======================================================================
225static Handle(DrawTrSurf_BSplineCurve2d) GetBSplineCurve2d(Standard_CString& Name)
226{
227 Handle(Draw_Drawable3D) D = Draw::Get(Name);
228 Handle(DrawTrSurf_BSplineCurve2d) Dr;
229 if (!D.IsNull())
230 Dr = Handle(DrawTrSurf_BSplineCurve2d)::DownCast(D);
231 return Dr;
232}
233
234
235//=======================================================================
236//function : nbiso
237//purpose :
238//=======================================================================
239static Standard_Integer nbiso (Draw_Interpretor& di, Standard_Integer n, const char** a)
240{
241 if (n < 4) {
242 if (n == 3) {
91322f44 243 NbUIsos = Draw::Atoi(a[1]);
244 NbVIsos = Draw::Atoi(a[2]);
7fd59977 245 }
246 di << NbUIsos << " " << NbVIsos;
247 }
248 else {
249 for (Standard_Integer i = 1; i < n - 2; i++) {
250 Handle(DrawTrSurf_Surface) DS = GetSurface(a[i]);
251 if (!DS.IsNull()) {
91322f44 252 DS->ShowIsos(Draw::Atoi(a[n-2]),Draw::Atoi(a[n-1]));
7fd59977 253 Draw::Repaint();
254 }
255 }
256 }
257 return 0;
258}
259
260//=======================================================================
261//function : drawpoles
262//purpose :
263//=======================================================================
264
265static Standard_Integer drawpoles(Draw_Interpretor&,
266 Standard_Integer n,
267 const char** a)
268{
269 if ( n == 1) {
270 if ( !strcmp(a[0],"shpoles")) {
271 ShowPoles = Standard_True;
272 }
273 else if ( !strcmp(a[0],"clpoles")) {
274 ShowPoles = Standard_False;
275 }
276 else if ( !strcmp(a[0],"shknots")) {
277 ShowKnots = Standard_True;
278 }
279 else if ( !strcmp(a[0],"clknots")) {
280 ShowKnots = Standard_False;
281 }
282 }
283
284 if ( n<2) return 1;
285
286 Handle(DrawTrSurf_BezierSurface) BZS;
287 BZS = GetBezierSurface(a[1]);
288 if ( !BZS.IsNull()) {
289 if ( !strcmp(a[0],"shpoles")) {
290 BZS->ShowPoles();
291 }
292 else if ( !strcmp(a[0],"clpoles")) {
293 BZS->ClearPoles();
294 }
295 else {
296 return 1;
297 }
298 }
299 else {
300 Handle(DrawTrSurf_BSplineSurface) BSS = GetBSplineSurface(a[1]);
301 if ( !BSS.IsNull()) {
302 if ( !strcmp(a[0],"shpoles")) {
303 BSS->ShowPoles();
304 }
305 else if ( !strcmp(a[0],"clpoles")) {
306 BSS->ClearPoles();
307 }
308 else if ( !strcmp(a[0],"shknots")) {
309 BSS->ShowKnots();
310 }
311 else if ( !strcmp(a[0],"clknots")) {
312 BSS->ClearKnots();
313 }
314 }
315 else {
316 Handle(DrawTrSurf_BezierCurve) BZC = GetBezierCurve(a[1]);
317 if ( !BZC.IsNull()) {
318 if ( !strcmp(a[0],"shpoles")) {
319 BZC->ShowPoles();
320 }
321 else if ( !strcmp(a[0],"clpoles")) {
322 BZC->ClearPoles();
323 }
324 else {
325 return 1;
326 }
327 }
328 else {
329 Handle(DrawTrSurf_BSplineCurve) BSC = GetBSplineCurve(a[1]);
330 if ( !BSC.IsNull()) {
331 if ( !strcmp(a[0],"shpoles")) {
332 BSC->ShowPoles();
333 }
334 else if ( !strcmp(a[0],"clpoles")) {
335 BSC->ClearPoles();
336 }
337 else if ( !strcmp(a[0],"shknots")) {
338 BSC->ShowKnots();
339 }
340 else if ( !strcmp(a[0],"clknots")) {
341 BSC->ClearKnots();
342 }
343 }
344 else {
345 Handle(DrawTrSurf_BezierCurve2d) BZ2 = GetBezierCurve2d(a[1]);
346 if ( !BZ2.IsNull()) {
347 if ( !strcmp(a[0],"shpoles")) {
348 BZ2->ShowPoles();
349 }
350 else if ( !strcmp(a[0],"clpoles")) {
351 BZ2->ClearPoles();
352 }
353 else {
354 return 1;
355 }
356 }
357 else {
358 Handle(DrawTrSurf_BSplineCurve2d) BS2 = GetBSplineCurve2d(a[1]);
359 if ( !BS2.IsNull()) {
360 if ( !strcmp(a[0],"shpoles")) {
361 BS2->ShowPoles();
362 }
363 else if ( !strcmp(a[0],"clpoles")) {
364 BS2->ClearPoles();
365 }
366 else if ( !strcmp(a[0],"shknots")) {
367 BS2->ShowKnots();
368 }
369 else if ( !strcmp(a[0],"clknots")) {
370 BS2->ClearKnots();
371 }
372 }
373 else {
374 return 1;
375 }
376 }
377 }
378 }
379 }
380 }
381 Draw::Repaint();
382 return 0;
383}
384
385//=======================================================================
386//function : draw
387//purpose :
388//=======================================================================
389
390static Standard_Integer draw (Draw_Interpretor& di, Standard_Integer n, const char** a)
391{
392 if (n <= 2) {
393 if (!strcmp(a[0],"dmode")) {
394 if (n == 2) {
7fd59977 395 DrawMode = 1;
396 }
397 if (DrawMode)
398 di << "u";
399 else
400 di << "d";
401 }
402
403 else if (!strcmp(a[0],"discr")) {
404 if (n == 2)
91322f44 405 Discret = Draw::Atoi(a[n-1]);
7fd59977 406 di << Discret;
407 }
408
409 else if (!strcmp(a[0],"defle")) {
410 if (n == 2)
91322f44 411 Deflection = Draw::Atof(a[n-1]);
7fd59977 412 di << Deflection;
413 }
414 }
415 else {
416 for (Standard_Integer i = 1; i < n - 1; i++) {
417 Handle(DrawTrSurf_Drawable) D = GetDrawable(a[1]);
418 if (!D.IsNull()) {
419 if (!strcmp(a[0],"dmode")) {
420 Standard_Integer mod = 0;
421 if ((*a[n-1] == 'U')||(*a[n-1] == 'u')) mod = 1;
422 D->SetDrawMode(mod);
423 }
424
425 else if (!strcmp(a[0],"discr")) {
91322f44 426 D->SetDiscretisation(Draw::Atoi(a[n-1]));
7fd59977 427 }
428
429 else if (!strcmp(a[0],"defle")) {
91322f44 430 D->SetDeflection(Draw::Atof(a[n-1]));
7fd59977 431 }
432
433 Draw::Repaint();
434 }
435 }
436 }
437 return 0;
438}
439
440//=======================================================================
441//function : transform
442//purpose :
443//=======================================================================
444
445static Standard_Integer transform (Draw_Interpretor& di, Standard_Integer n, const char** a)
446{
447 if (n < 5) return 1;
448 gp_Trsf T;
449 Standard_Integer i,last = n-1;
450 if (!strcmp(a[0],"pscale")) {
91322f44 451 Standard_Real s = Draw::Atof(a[last]);
7fd59977 452 last--;
453 if (last < 4) return 1;
91322f44 454 gp_Pnt P(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 455 T.SetScale(P,s);
456 }
457 else if (!strcmp(a[0]+1,"mirror")) {
458 if (last < 4) return 1;
91322f44 459 gp_Pnt P(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 460 if (*a[0] == 'p') {
461 T.SetMirror(P);
462 }
463 else {
464 last -= 3;
465 if (last < 4) return 1;
91322f44 466 gp_Pnt O(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 467 last -= 3;
468 gp_Dir D(P.X(),P.Y(),P.Z());
469 if (*a[0] == 'l') {
470 T.SetMirror(gp_Ax1(O,D));
471 }
472 else if (*a[0] == 's') {
473 gp_Pln Pl(O,D);
474 T.SetMirror(Pl.Position().Ax2());
475 }
476 }
477 }
478
479 else if (!strcmp(a[0],"translate")) {
480 if (last < 4) return 1;
91322f44 481 gp_Vec V(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 482 last -= 3;
483 T.SetTranslation(V);
484 }
485
486 else if (!strcmp(a[0],"rotate")) {
487 if (last < 8) return 1;
91322f44 488 Standard_Real ang = Draw::Atof(a[last]) * (M_PI / 180.0);
7fd59977 489 last --;
91322f44 490 gp_Dir D(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 491 last -= 3;
91322f44 492 gp_Pnt P(Draw::Atof(a[last-2]),Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 493 last -= 3;
494 T.SetRotation(gp_Ax1(P,D),ang);
495 }
496
497 for (i = 1; i <= last; i++) {
498 Handle(Geom_Geometry) G = DrawTrSurf::Get(a[i]);
499 if (!G.IsNull()) {
500 G->Transform(T);
501 Draw::Repaint();
502 }
503 else {
504 gp_Pnt P;
505 if (DrawTrSurf::GetPoint(a[i],P)) {
506 P.Transform(T);
507 DrawTrSurf::Set(a[i],P);
508 }
509 }
510 di << a[i] << " ";
511 }
512 return 0;
513}
514
515//=======================================================================
516//function : d2transform
517//purpose :
518//=======================================================================
519
520static Standard_Integer d2transform (Draw_Interpretor& di, Standard_Integer n, const char** a)
521{
522 if (n < 4) return 1;
523 gp_Trsf2d T;
524 Standard_Integer i,last = n-1;
525 if (!strcmp(a[0],"2dpscale")) {
91322f44 526 Standard_Real s = Draw::Atof(a[last]);
7fd59977 527 last--;
528 if (last < 3) return 1;
91322f44 529 gp_Pnt2d P(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 530 T.SetScale(P,s);
531 }
532 else if ( (!strcmp(a[0],"2dpmirror")) ||
533 (!strcmp(a[0],"2dlmirror")) ) {
534 if (last < 3) return 1;
91322f44 535 gp_Pnt2d P(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 536 if (!strcmp(a[0],"2dpmirror")) {
537 T.SetMirror(P);
538 }
539 else {
540 last -= 2;
541 if (last < 3) return 1;
91322f44 542 gp_Pnt2d O(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 543 last -= 2;
544 gp_Dir2d D(P.X(),P.Y());
545 T.SetMirror(gp_Ax2d(O,D));
546 }
547 }
548
549 else if (!strcmp(a[0],"2dtranslate")) {
550 if (last < 3) return 1;
91322f44 551 gp_Vec2d V(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 552 last -= 2;
553 T.SetTranslation(V);
554 }
555
556 else if (!strcmp(a[0],"2drotate")) {
557 if (last < 4) return 1;
91322f44 558 Standard_Real ang = Draw::Atof(a[last]) * (M_PI / 180.0);
7fd59977 559 last --;
91322f44 560 gp_Pnt2d P(Draw::Atof(a[last-1]),Draw::Atof(a[last]));
7fd59977 561 last -= 2;
562 T.SetRotation(P,ang);
563 }
564
565 for (i = 1; i <= last; i++) {
566 Handle(Geom2d_Curve) G = DrawTrSurf::GetCurve2d(a[i]);
567 if (!G.IsNull()) {
568 G->Transform(T);
569 Draw::Repaint();
570 }
571 else {
572 gp_Pnt2d P;
573 if (DrawTrSurf::GetPoint2d(a[i],P)) {
574 P.Transform(T);
575 DrawTrSurf::Set(a[i],P);
576 }
577 }
578 di << a[i] << " ";
579 }
580 return 0;
581}
582
583//=======================================================================
584//function : Set
585//purpose : point
586//=======================================================================
587void DrawTrSurf::Set(const Standard_CString Name,
588 const gp_Pnt& P)
589{
590 Handle(DrawTrSurf_Point) DP = new DrawTrSurf_Point(P,PntShape,PntColor);
591 Draw::Set(Name,DP);
592}
593
594//=======================================================================
595//function : Set
596//purpose : point
597//=======================================================================
598void DrawTrSurf::Set(const Standard_CString Name,
599 const gp_Pnt2d& P)
600{
601 Handle(DrawTrSurf_Point) DP = new DrawTrSurf_Point(P,PntShape,PntColor);
602 Draw::Set(Name,DP);
603}
604
605//=======================================================================
606//function : Set
607//purpose : Geometry from Geom
608//=======================================================================
609void DrawTrSurf::Set(const Standard_CString Name,
445f3267
S
610 const Handle(Geom_Geometry)& G,
611 const Standard_Boolean isSenseMarker)
7fd59977 612{
613 Handle(DrawTrSurf_Drawable) D;
614 if (!G.IsNull()) {
615
616 Handle(Geom_Curve) C = Handle(Geom_Curve)::DownCast(G);
617 if (!C.IsNull()) {
618
619 Handle(Geom_BezierCurve) Bez =
620 Handle(Geom_BezierCurve)::DownCast(C);
621 if (!Bez.IsNull()) {
622 Handle(DrawTrSurf_BezierCurve) DBez =
623 new DrawTrSurf_BezierCurve(Bez,CurvColor,PolesColor,ShowPoles,
624 Discret,Deflection,DrawMode);
625 D = DBez;
626 }
627
628
629 Handle(Geom_BSplineCurve) BS =
630 Handle(Geom_BSplineCurve)::DownCast(C);
631 if (!BS.IsNull()) {
632 Handle(DrawTrSurf_BSplineCurve) DBS =
633 new DrawTrSurf_BSplineCurve(BS,
634 CurvColor,PolesColor,
635 KnotsColor,
636 KnotsShape,KnotsSize,
637 ShowPoles,ShowKnots,
638 Discret,Deflection,DrawMode);
639 D = DBS;
640 }
641
642 if (Bez.IsNull() && BS.IsNull()) {
643 Handle(DrawTrSurf_Curve) DC =
445f3267 644 new DrawTrSurf_Curve(C,CurvColor,Discret,Deflection,DrawMode,isSenseMarker);
7fd59977 645 D = DC;
646 }
647 }
648
649
650 Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(G);
651 if (!S.IsNull()) {
652
653 Handle(Geom_BezierSurface) Bez =
654 Handle(Geom_BezierSurface)::DownCast(S);
655 if (!Bez.IsNull()) {
656 Handle(DrawTrSurf_BezierSurface) DBez =
657 new DrawTrSurf_BezierSurface(Bez,NbUIsos,NbVIsos,
658 BoundsColor,IsosColor,PolesColor,
659 ShowPoles,
660 Discret,Deflection,DrawMode);
661 D = DBez;
662 }
663
664
665 Handle(Geom_BSplineSurface) BS =
666 Handle(Geom_BSplineSurface)::DownCast(S);
667 if (!BS.IsNull()) {
668 Handle(DrawTrSurf_BSplineSurface) DBS ;
669 if (!knotsIsos)
670 DBS = new DrawTrSurf_BSplineSurface(BS,
671 NbUIsos,NbVIsos,
672 BoundsColor,IsosColor,
673 PolesColor,KnotsColor,
674 KnotsShape,KnotsSize,
675 ShowPoles,ShowKnots,
676 Discret,Deflection,DrawMode);
677 else
678 DBS = new DrawTrSurf_BSplineSurface(BS,
679 BoundsColor,IsosColor,
680 PolesColor,KnotsColor,
681 KnotsShape,KnotsSize,
682 ShowPoles,ShowKnots,
683 Discret,Deflection,DrawMode);
684
685 D = DBS;
686 }
687
688 if (Bez.IsNull() && BS.IsNull()) {
689 Handle(DrawTrSurf_Surface) DS =
690 new DrawTrSurf_Surface(S,
691 NbUIsos,NbVIsos,
692 BoundsColor,IsosColor,
693 Discret,Deflection,DrawMode);
694 D = DS;
695 }
696 }
697
698 }
699 Draw::Set(Name,D);
700}
701
702
703//=======================================================================
704//function : Set
705//purpose : Curve from Geom2d
706//=======================================================================
707void DrawTrSurf::Set(const Standard_CString Name,
445f3267
S
708 const Handle(Geom2d_Curve)& C,
709 const Standard_Boolean isSenseMarker)
7fd59977 710{
711 Handle(DrawTrSurf_Drawable) D;
712 if (!C.IsNull()) {
713
714 Handle(Geom2d_BezierCurve) Bez =
715 Handle(Geom2d_BezierCurve)::DownCast(C);
716 if (!Bez.IsNull()) {
717 Handle(DrawTrSurf_BezierCurve2d) DBez =
718 new DrawTrSurf_BezierCurve2d(Bez,CurvColor,PolesColor,ShowPoles,
719 Discret);
720 D = DBez;
721 }
722
723
724 Handle(Geom2d_BSplineCurve) BS =
725 Handle(Geom2d_BSplineCurve)::DownCast(C);
726 if (!BS.IsNull()) {
727 Handle(DrawTrSurf_BSplineCurve2d) DBS =
728 new DrawTrSurf_BSplineCurve2d(BS,
729 CurvColor,PolesColor,
730 KnotsColor,
731 KnotsShape,KnotsSize,
732 ShowPoles,ShowKnots,
733 Discret);
734 D = DBS;
735 }
736
737 if (Bez.IsNull() && BS.IsNull()) {
738 Handle(DrawTrSurf_Curve2d) DC =
445f3267 739 new DrawTrSurf_Curve2d(C,CurvColor,Discret,isSenseMarker);
7fd59977 740 D = DC;
741 }
742 }
743
744 Draw::Set(Name,D);
745}
746
747//=======================================================================
748//function : Set
749//purpose :
750//=======================================================================
751void DrawTrSurf::Set(const Standard_CString Name,
752 const Handle(Poly_Triangulation)& T)
753{
754 Handle(DrawTrSurf_Triangulation) D = new DrawTrSurf_Triangulation(T);
755 Draw::Set(Name,D);
756}
757//=======================================================================
758//function : Set
759//purpose :
760//=======================================================================
761void DrawTrSurf::Set(const Standard_CString Name,
762 const Handle(Poly_Polygon3D)& P)
763{
764 Handle(DrawTrSurf_Polygon3D) D = new DrawTrSurf_Polygon3D(P);
765 Draw::Set(Name,D);
766}
767
768//=======================================================================
769//function : Set
770//purpose :
771//=======================================================================
772void DrawTrSurf::Set(const Standard_CString Name,
773 const Handle(Poly_Polygon2D)& P)
774{
775 Handle(DrawTrSurf_Polygon2D) D = new DrawTrSurf_Polygon2D(P);
776 Draw::Set(Name,D);
777}
778
779//=======================================================================
780//function : Get
781//purpose :
782//=======================================================================
783Handle(Geom_Geometry) DrawTrSurf::Get(Standard_CString& Name)
784{
785 Handle(Draw_Drawable3D) D = Draw::Get(Name);
786
787 Handle(DrawTrSurf_Curve) DC =
788 Handle(DrawTrSurf_Curve)::DownCast(D);
789 if (!DC.IsNull())
790 return DC->GetCurve();
791
792 Handle(DrawTrSurf_Surface) DS =
793 Handle(DrawTrSurf_Surface)::DownCast(D);
794 if (!DS.IsNull())
795 return DS->GetSurface();
796
797 return Handle(Geom_Geometry) ();
798}
799
800
801//=======================================================================
802//function : GetPoint
803//purpose :
804//=======================================================================
805Standard_Boolean DrawTrSurf::GetPoint(Standard_CString& Name,
806 gp_Pnt& P)
807{
808 Handle(DrawTrSurf_Point) D =
809 Handle(DrawTrSurf_Point)::DownCast(Draw::Get(Name));
810 if (D.IsNull())
811 return Standard_False;
812 else if (!D->Is3D())
813 return Standard_False;
814 else {
815 P = D->Point();
816 return Standard_True;
817 }
818}
819
820//=======================================================================
821//function : GetPoint2d
822//purpose :
823//=======================================================================
824Standard_Boolean DrawTrSurf::GetPoint2d(Standard_CString& Name,
825 gp_Pnt2d& P)
826{
827 Handle(DrawTrSurf_Point) D =
828 Handle(DrawTrSurf_Point)::DownCast(Draw::Get(Name));
829 if (D.IsNull())
830 return Standard_False;
831 else if (D->Is3D())
832 return Standard_False;
833 else {
834 P = D->Point2d();
835 return Standard_True;
836 }
837}
838
839//=======================================================================
840//function : GetCurve
841//purpose :
842//=======================================================================
843Handle(Geom_Curve) DrawTrSurf::GetCurve(Standard_CString& Name)
844{
845 Handle(DrawTrSurf_Curve) D =
846 Handle(DrawTrSurf_Curve)::DownCast(Draw::Get(Name));
847 if (D.IsNull())
848 return Handle(Geom_Curve)();
849 else
850 return D->GetCurve();
851}
852
853
854//=======================================================================
855//function : GetBezierCurve
856//purpose :
857//=======================================================================
858Handle(Geom_BezierCurve) DrawTrSurf::GetBezierCurve(Standard_CString& Name)
859{
860 Handle(DrawTrSurf_BezierCurve) D =
861 Handle(DrawTrSurf_BezierCurve)::DownCast(Draw::Get(Name));
862 if (D.IsNull())
863 return Handle(Geom_BezierCurve)();
864 else
865 return Handle(Geom_BezierCurve)::DownCast(D->GetCurve());
866}
867
868
869//=======================================================================
870//function : GetBSplineCurve
871//purpose :
872//=======================================================================
873Handle(Geom_BSplineCurve) DrawTrSurf::GetBSplineCurve(Standard_CString& Name)
874{
875 Handle(DrawTrSurf_BSplineCurve) D =
876 Handle(DrawTrSurf_BSplineCurve)::DownCast(Draw::Get(Name));
877 if (D.IsNull())
878 return Handle(Geom_BSplineCurve)();
879 else
880 return Handle(Geom_BSplineCurve)::DownCast(D->GetCurve());
881}
882//=======================================================================
883//function : GetCurve2d
884//purpose :
885//=======================================================================
886Handle(Geom2d_Curve) DrawTrSurf::GetCurve2d(Standard_CString& Name)
887{
888 Handle(DrawTrSurf_Curve2d) D =
889 Handle(DrawTrSurf_Curve2d)::DownCast(Draw::Get(Name));
890 if (D.IsNull())
891 return Handle(Geom2d_Curve)();
892 else
893 return D->GetCurve();
894}
895//=======================================================================
896//function : GetBezierCurve2d
897//purpose :
898//=======================================================================
899Handle(Geom2d_BezierCurve) DrawTrSurf::GetBezierCurve2d(Standard_CString& Name)
900{
901 Handle(DrawTrSurf_Curve2d) D =
902 Handle(DrawTrSurf_Curve2d)::DownCast(Draw::Get(Name));
903 if (D.IsNull())
904 return Handle(Geom2d_BezierCurve)();
905 else
906 return Handle(Geom2d_BezierCurve)::DownCast(D->GetCurve());
907}
908//=======================================================================
909//function : GetBSplineCurve2d
910//purpose :
911//=======================================================================
912Handle(Geom2d_BSplineCurve) DrawTrSurf::GetBSplineCurve2d
913 (Standard_CString& Name)
914{
915 Handle(DrawTrSurf_Curve2d) D =
916 Handle(DrawTrSurf_Curve2d)::DownCast(Draw::Get(Name));
917 if (D.IsNull())
918 return Handle(Geom2d_BSplineCurve)();
919 else
920 return Handle(Geom2d_BSplineCurve)::DownCast(D->GetCurve());
921}
922//=======================================================================
923//function : GetSurface
924//purpose :
925//=======================================================================
926Handle(Geom_Surface) DrawTrSurf::GetSurface
927 (Standard_CString& Name)
928{
929 Handle(DrawTrSurf_Surface) D =
930 Handle(DrawTrSurf_Surface)::DownCast(Draw::Get(Name));
931 if (D.IsNull())
932 return Handle(Geom_Surface)();
933 else
934 return D->GetSurface();
935}
936//=======================================================================
937//function : GetBezierSurface
938//purpose :
939//=======================================================================
940Handle(Geom_BezierSurface) DrawTrSurf::GetBezierSurface
941 (Standard_CString& Name)
942{
943 Handle(DrawTrSurf_BezierSurface) D =
944 Handle(DrawTrSurf_BezierSurface)::DownCast(Draw::Get(Name));
945 if (D.IsNull())
946 return Handle(Geom_BezierSurface)();
947 else
948 return Handle(Geom_BezierSurface)::DownCast(D->GetSurface());
949}
950//=======================================================================
951//function : GetBSplineSurface
952//purpose :
953//=======================================================================
954Handle(Geom_BSplineSurface) DrawTrSurf::GetBSplineSurface
955 (Standard_CString& Name)
956{
957 Handle(DrawTrSurf_BSplineSurface) D =
958 Handle(DrawTrSurf_BSplineSurface)::DownCast(Draw::Get(Name));
959 if (D.IsNull())
960 return Handle(Geom_BSplineSurface)();
961 else
962 return Handle(Geom_BSplineSurface)::DownCast(D->GetSurface());
963}
964//=======================================================================
965//function : GetTriangulation
966//purpose :
967//=======================================================================
968Handle(Poly_Triangulation) DrawTrSurf::GetTriangulation(Standard_CString& Name)
969{
970 Handle(DrawTrSurf_Triangulation) D =
971 Handle(DrawTrSurf_Triangulation)::DownCast(Draw::Get(Name));
972 if (D.IsNull())
973 return Handle(Poly_Triangulation)();
974 else
975 return D->Triangulation();
976}
977//=======================================================================
978//function : GetPolygon3D
979//purpose :
980//=======================================================================
981Handle(Poly_Polygon3D) DrawTrSurf::GetPolygon3D(Standard_CString& Name)
982{
983 Handle(DrawTrSurf_Polygon3D) D =
984 Handle(DrawTrSurf_Polygon3D)::DownCast(Draw::Get(Name));
985 if (D.IsNull())
986 return Handle(Poly_Polygon3D)();
987 else
988 return D->Polygon3D();
989}
990//=======================================================================
991//function : GetPolygon2D
992//purpose :
993//=======================================================================
994Handle(Poly_Polygon2D) DrawTrSurf::GetPolygon2D(Standard_CString& Name)
995{
996 Handle(DrawTrSurf_Polygon2D) D =
997 Handle(DrawTrSurf_Polygon2D)::DownCast(Draw::Get(Name));
998 if (D.IsNull())
999 return Handle(Poly_Polygon2D)();
1000 else
1001 return D->Polygon2D();
1002}
445f3267
S
1003
1004//=======================================================================
1005//function : printColor
1006//purpose :
1007//=======================================================================
1008
1009static void printColor(Draw_Interpretor& di, const Draw_Color& theColor)
1010{
1011 switch ( theColor.ID() )
1012 {
1013 case Draw_blanc: di << "white " << "\n"; break;
1014 case Draw_rouge: di << "red " << "\n"; break;
1015 case Draw_vert: di << "green " << "\n"; break;
1016 case Draw_bleu: di << "blue " << "\n"; break;
1017 case Draw_cyan: di << "cyan " << "\n"; break;
1018 case Draw_or: di << "golden " << "\n"; break;
1019 case Draw_magenta: di << "magenta " << "\n"; break;
1020 case Draw_marron: di << "brown " << "\n"; break;
1021 case Draw_orange: di << "orange " << "\n"; break;
1022 case Draw_rose: di << "pink " << "\n"; break;
1023 case Draw_saumon: di << "salmon " << "\n"; break;
1024 case Draw_violet: di << "violet " << "\n"; break;
1025 case Draw_jaune: di << "yellow " << "\n"; break;
1026 case Draw_kaki: di << "dark-olive green " << "\n"; break;
1027 case Draw_corail: di << "coral " << "\n"; break;
1028 }
1029}
1030
1031//=======================================================================
1032//function : recognizeColor
1033//purpose :
1034//=======================================================================
1035
1036static Draw_Color recognizeColor(const char* theColorStr,
1037 const Draw_Color& theDefaultColor)
1038{
1039 Draw_Color aResult = theDefaultColor;
1040
1041 if ( !strcasecmp(theColorStr,"white") )
1042 aResult = Draw_blanc;
1043 if ( !strcasecmp(theColorStr, "red") )
1044 aResult = Draw_rouge;
1045 if ( !strcasecmp(theColorStr, "green") )
1046 aResult = Draw_vert;
1047 if ( !strcasecmp(theColorStr, "blue") )
1048 aResult = Draw_bleu;
1049 if ( !strcasecmp(theColorStr, "cyan") )
1050 aResult = Draw_cyan;
1051 if ( !strcasecmp(theColorStr, "golden") )
1052 aResult = Draw_or;
1053 if ( !strcasecmp(theColorStr, "magenta") )
1054 aResult = Draw_magenta;
1055 if ( !strcasecmp(theColorStr, "brown") )
1056 aResult = Draw_marron;
1057 if ( !strcasecmp(theColorStr, "orange") )
1058 aResult = Draw_orange;
1059 if ( !strcasecmp(theColorStr, "pink") )
1060 aResult = Draw_rose;
1061 if ( !strcasecmp(theColorStr, "salmon") )
1062 aResult = Draw_saumon;
1063 if ( !strcasecmp(theColorStr, "violet") )
1064 aResult = Draw_violet;
1065 if ( !strcasecmp(theColorStr, "yellow") )
1066 aResult = Draw_jaune;
1067 if ( !strcasecmp(theColorStr, "darkgreen") )
1068 aResult = Draw_kaki;
1069 if ( !strcasecmp(theColorStr, "coral") )
1070 aResult = Draw_corail;
1071
1072 return aResult;
1073}
1074
7fd59977 1075//=======================================================================
1076//function : setcurvcolor
1077//purpose :
1078//=======================================================================
445f3267
S
1079
1080static Standard_Integer setcurvcolor(Draw_Interpretor& di,
1081 Standard_Integer n, const char** a)
7fd59977 1082{
445f3267 1083 Draw_Color col, savecol;
7fd59977 1084
1085 savecol = DrawTrSurf_CurveColor(Draw_Color(Draw_jaune));
1086 DrawTrSurf_CurveColor(savecol);
1087
445f3267
S
1088 if (n < 2)
1089 {
1090 printColor(di, savecol);
1091 }
1092 else {
1093 col = recognizeColor(a[1], savecol);
7fd59977 1094 DrawTrSurf_CurveColor(col);
7fd59977 1095 }
1096 return 0;
1097}
1098
1099//=======================================================================
1100//function : changecurvcolor
1101//purpose :
1102//=======================================================================
1103
445f3267
S
1104static Standard_Integer changecurvcolor(Draw_Interpretor&,
1105 Standard_Integer n, const char** a)
7fd59977 1106{
445f3267 1107 Draw_Color col, savecol;
7fd59977 1108
1109 savecol = DrawTrSurf_CurveColor(Draw_Color(Draw_jaune));
1110 DrawTrSurf_CurveColor(savecol);
1111
445f3267
S
1112 if ( n < 3 )
1113 return 1;
1114
1115 col = recognizeColor(a[1], savecol);
7fd59977 1116
445f3267
S
1117 Handle(DrawTrSurf_Curve) D = Handle(DrawTrSurf_Curve)::DownCast( Draw::Get(a[2]) );
1118 if ( !D.IsNull() )
1119 {
7fd59977 1120 D->SetColor(col);
445f3267
S
1121 Draw::Repaint();
1122 }
1123
1124 return 0;
1125}
1126
1127//=======================================================================
1128//function : setpointcolor
1129//purpose :
1130//=======================================================================
1131
1132static Standard_Integer setpointcolor(Draw_Interpretor& di,
1133 Standard_Integer n, const char** a)
1134{
1135 Draw_Color col, savecol;
1136
1137 savecol = DrawTrSurf_PointColor(Draw_Color(Draw_jaune));
1138 DrawTrSurf_PointColor(savecol);
1139
1140 if (n < 2)
1141 {
1142 printColor(di, savecol);
1143 }
1144 else {
1145 col = recognizeColor(a[1], savecol);
1146 DrawTrSurf_PointColor(col);
1147 }
1148 return 0;
1149}
1150
1151//=======================================================================
1152//function : changepointcolor
1153//purpose :
1154//=======================================================================
1155
1156static Standard_Integer changepointcolor(Draw_Interpretor&,
1157 Standard_Integer n, const char** a)
1158{
1159 Draw_Color col, savecol;
1160
1161 savecol = DrawTrSurf_PointColor(Draw_Color(Draw_jaune));
1162 DrawTrSurf_PointColor(savecol);
1163
1164 if ( n < 3 )
1165 return 1;
1166
1167 col = recognizeColor(a[1], savecol);
1168
1169 Handle(DrawTrSurf_Point) D = Handle(DrawTrSurf_Point)::DownCast( Draw::Get(a[2]) );
1170 if ( !D.IsNull() )
1171 {
1172 D->Color(col);
1173 Draw::Repaint();
7fd59977 1174 }
1175
1176 return 0;
1177}
1178
445f3267
S
1179//=======================================================================
1180//function : printMarker
1181//purpose :
1182//=======================================================================
1183
1184static void printMarker(Draw_Interpretor& di, const Draw_MarkerShape& theMarker)
1185{
1186 switch ( theMarker )
1187 {
1188 case Draw_Square: di << "square " << "\n"; break;
1189 case Draw_Losange: di << "diamond " << "\n"; break;
1190 case Draw_X: di << "x " << "\n"; break;
1191 case Draw_Plus: di << "plus " << "\n"; break;
1192 case Draw_Circle: di << "circle " << "\n"; break;
1193 case Draw_CircleZoom: di << "circle_zoom " << "\n"; break;
1194 }
1195}
1196
1197//=======================================================================
1198//function : recognizeMarker
1199//purpose :
1200//=======================================================================
1201
1202static Draw_MarkerShape recognizeMarker(const char* theMarkerStr,
1203 const Draw_MarkerShape& theDefaultMarker)
1204{
1205 Draw_MarkerShape aResult = theDefaultMarker;
1206
1207 if ( !strcasecmp(theMarkerStr, "square") )
1208 aResult = Draw_Square;
1209 if ( !strcasecmp(theMarkerStr, "diamond") )
1210 aResult = Draw_Losange;
1211 if ( !strcasecmp(theMarkerStr, "x") )
1212 aResult = Draw_X;
1213 if ( !strcasecmp(theMarkerStr, "plus") )
1214 aResult = Draw_Plus;
1215 if ( !strcasecmp(theMarkerStr, "circle") )
1216 aResult = Draw_Circle;
1217 if ( !strcasecmp(theMarkerStr, "circle_zoom") )
1218 aResult = Draw_CircleZoom;
1219
1220 return aResult;
1221}
1222
1223//=======================================================================
1224//function : setpointmarker
1225//purpose :
1226//=======================================================================
1227
1228static Standard_Integer setpointmarker(Draw_Interpretor& di,
1229 Standard_Integer n, const char** a)
1230{
1231 Draw_MarkerShape mark, savemark;
1232
1233 savemark = DrawTrSurf_PointMarker(Draw_MarkerShape(Draw_Plus));
1234 DrawTrSurf_PointMarker(savemark);
1235
1236 if ( n < 2 )
1237 {
1238 printMarker(di, savemark);
1239 }
1240 else {
1241 mark = recognizeMarker(a[1], savemark);
1242 DrawTrSurf_PointMarker(mark);
1243 }
1244 return 0;
1245}
1246
1247//=======================================================================
1248//function : changepointmarker
1249//purpose :
1250//=======================================================================
1251
1252static Standard_Integer changepointmarker(Draw_Interpretor&,
1253 Standard_Integer n, const char** a)
1254{
1255 Draw_MarkerShape mark, savemark;
1256
1257 savemark = DrawTrSurf_PointMarker(Draw_MarkerShape(Draw_Plus));
1258 DrawTrSurf_PointMarker(savemark);
1259
1260 if ( n < 3 )
1261 return 1;
1262
1263 mark = recognizeMarker(a[1], savemark);
1264
1265 Handle(DrawTrSurf_Point) D = Handle(DrawTrSurf_Point)::DownCast( Draw::Get(a[2]) );
1266 if ( !D.IsNull() )
1267 {
1268 D->Shape(mark);
1269 Draw::Repaint();
1270 }
1271
1272 return 0;
1273}
7fd59977 1274
1275//=======================================================================
1276//function : BasicCommands
1277//purpose :
1278//=======================================================================
1279
1280static Standard_Boolean done = Standard_False;
1281void DrawTrSurf::BasicCommands(Draw_Interpretor& theCommands)
1282{
1283 if (done) return;
1284 done = Standard_True;
1285
1286 const char* g;
1287 g = "geometric display commands";
1288
1289 theCommands.Add("nbiso",
1290 "nbiso name [names...] nuiso nviso",
1291 __FILE__,
1292 nbiso,g);
1293
1294 theCommands.Add("clpoles",
1295 "clpoles [name], no args : modal ",
1296 __FILE__,
1297 drawpoles,g);
1298
1299 theCommands.Add("shpoles",
1300 "shpoles [name], no args : modal ",
1301 __FILE__,
1302 drawpoles,g);
1303
1304 theCommands.Add("clknots",
1305 "clknots [name], no args : modal ",
1306 __FILE__,
1307 drawpoles,g);
1308
1309 theCommands.Add("shknots",
1310 "shknots [name], no args : modal ",
1311 __FILE__,
1312 drawpoles,g);
1313
1314 theCommands.Add("dmode",
1315 "dmode [names...] Uniform/Discret",
1316 __FILE__,
1317 draw,g);
1318
1319 theCommands.Add("discr",
1320 "discr [names...] nbintervals",
1321 __FILE__,
1322 draw,g);
1323
1324 theCommands.Add("defle",
1325 "defle [names...] defle",
1326 __FILE__,
1327 draw,g);
445f3267
S
1328
1329 theCommands.Add("setcurvcolor",
1330 TCollection_AsciiString("setcurvcolor [color] : set curve color\
1331 by default, or print the current curve color if no argument (this does not modify\
1332 the color of the curve)\n\n").Cat(ColorsHint).ToCString(),
7fd59977 1333 __FILE__,setcurvcolor,g);
1334
445f3267
S
1335 theCommands.Add("changecurvcolor",
1336 TCollection_AsciiString("changecurvcolor color curve: change\
1337 color of the curve\n\n").Cat(ColorsHint).ToCString(),
7fd59977 1338 __FILE__,changecurvcolor,g);
1339
445f3267
S
1340 theCommands.Add("setpointcolor",
1341 TCollection_AsciiString("setpointcolor [color] : set point color\
1342 by default, or print the current point color if no argument (this does not modify\
1343 the color of the point)\n\n").Cat(ColorsHint).ToCString(),
1344 __FILE__,setpointcolor,g);
1345
1346 theCommands.Add("changepointcolor",
1347 TCollection_AsciiString("changepointcolor color point: change\
1348 color of the point\n\n").Cat(ColorsHint).ToCString(),
1349 __FILE__,changepointcolor,g);
1350
1351 theCommands.Add("setpointmarker",
1352 TCollection_AsciiString("setpointmarker [marker] : set point marker\
1353 by default, or print the current point marker if no argument (this does not modify\
1354 the marker of the point)\n\n").Cat(MarkersHint).ToCString(),
1355 __FILE__,setpointmarker,g);
1356
1357 theCommands.Add("changepointmarker",
1358 TCollection_AsciiString("changepointmarker marker point: change\
1359 marker of the point\n\n").Cat(MarkersHint).ToCString(),
1360 __FILE__,changepointmarker,g);
1361
7fd59977 1362 g = "Geometric tranformations";
1363
1364 theCommands.Add("translate",
1365 "translate name [names...] dx dy dz",
1366 __FILE__,
1367 transform,g);
1368
1369 theCommands.Add("rotate",
1370 "rotate name [names...] x y z dx dy dz angle",
1371 __FILE__,
1372 transform,g);
1373
1374 theCommands.Add("pmirror",
1375 "pmirror name [names...] x y z",
1376 __FILE__,
1377 transform,g);
1378
1379 theCommands.Add("lmirror",
1380 "lmirror name [names...] x y z dx dy dz",
1381 __FILE__,
1382 transform,g);
1383
1384 theCommands.Add("smirror",
1385 "smirror name [names...] x y z dx dy dz",
1386 __FILE__,
1387 transform,g);
1388
1389 theCommands.Add("pscale",
1390 "pscale name [names...] x y z s",
1391 __FILE__,
1392 transform,g);
1393
1394 theCommands.Add("2dtranslate",
1395 "translate name [names...] dx dy",
1396 __FILE__,
1397 d2transform,g);
1398
1399 theCommands.Add("2drotate",
1400 "rotate name [names...] x y dx dy angle",
1401 __FILE__,
1402 d2transform,g);
1403
1404 theCommands.Add("2dpmirror",
1405 "pmirror name [names...] x y",
1406 __FILE__,
1407 d2transform,g);
1408
1409 theCommands.Add("2dlmirror",
1410 "lmirror name [names...] x y dx dy",
1411 __FILE__,
1412 d2transform,g);
1413
1414 theCommands.Add("2dpscale",
1415 "pscale name [names...] x y s",
1416 __FILE__,
1417 d2transform,g);
1418}
1419
1420
1421//=================================================================
1422// save and restore curves
1423//=================================================================
1424
1425static Standard_Boolean ctest(const Handle(Draw_Drawable3D)& d)
1426{
1427 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Curve));
1428}
1429
1430static void csave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1431{
1432 Handle(DrawTrSurf_Curve) N = Handle(DrawTrSurf_Curve)::DownCast(d);
1433 GeomTools_CurveSet::PrintCurve(N->GetCurve(),OS,Standard_True);
1434}
1435
1436static Handle(Draw_Drawable3D) crestore (istream& is)
1437{
1438 Handle(Geom_Curve) G;
1439 GeomTools_CurveSet::ReadCurve(is,G);
1440 Handle(DrawTrSurf_Curve) N =
1441 new DrawTrSurf_Curve(G,CurvColor,Discret,Deflection,DrawMode);
1442 return N;
1443}
1444
1445
1446static Draw_SaveAndRestore csr("DrawTrSurf_Curve",
1447 ctest,csave,crestore);
1448
1449
1450
1451
1452//=================================================================
1453// save and restore bezier curves
1454//=================================================================
1455
1456static Standard_Boolean bzctest(const Handle(Draw_Drawable3D)& d)
1457{
1458 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BezierCurve));
1459}
1460
1461static void bzcsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1462{
1463 Handle(DrawTrSurf_BezierCurve)
1464 N = Handle(DrawTrSurf_BezierCurve)::DownCast(d);
1465 GeomTools_CurveSet::PrintCurve(N->GetCurve(),OS,Standard_True);
1466}
1467
1468static Handle(Draw_Drawable3D) bzcrestore (istream& is)
1469{
1470 Handle(Geom_BezierCurve) G;
1471 GeomTools_CurveSet::ReadCurve(is,G);
1472 Handle(DrawTrSurf_BezierCurve) N =
1473 new DrawTrSurf_BezierCurve(G,CurvColor,PolesColor,ShowPoles,
1474 Discret,Deflection,DrawMode);
1475 return N;
1476}
1477
1478
1479static Draw_SaveAndRestore bzcsr("DrawTrSurf_BezierCurve",
1480 bzctest,bzcsave,bzcrestore);
1481
1482
1483
1484
1485//=================================================================
1486// save and restore bspline curves
1487//=================================================================
1488
1489static Standard_Boolean bsctest(const Handle(Draw_Drawable3D)& d)
1490{
1491 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BSplineCurve));
1492}
1493
1494static void bscsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1495{
1496 Handle(DrawTrSurf_BSplineCurve)
1497 N = Handle(DrawTrSurf_BSplineCurve)::DownCast(d);
1498 GeomTools_CurveSet::PrintCurve(N->GetCurve(),OS,Standard_True);
1499}
1500
1501static Handle(Draw_Drawable3D) bscrestore (istream& is)
1502{
1503 Handle(Geom_BSplineCurve) G;
1504 GeomTools_CurveSet::ReadCurve(is,G);
1505 Handle(DrawTrSurf_BSplineCurve) N =
1506 new DrawTrSurf_BSplineCurve(G, CurvColor,PolesColor,
1507 KnotsColor,
1508 KnotsShape,KnotsSize,
1509 ShowPoles,ShowKnots,
1510 Discret,Deflection,DrawMode);
1511 return N;
1512}
1513
1514
1515static Draw_SaveAndRestore bscsr("DrawTrSurf_BSplineCurve",
1516 bsctest,bscsave,bscrestore);
1517
1518
1519//=================================================================
1520// save and restore curves 2d
1521//=================================================================
1522
1523static Standard_Boolean c2dtest(const Handle(Draw_Drawable3D)& d)
1524{
1525 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Curve2d));
1526}
1527
1528static void c2dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1529{
1530 Handle(DrawTrSurf_Curve2d) N = Handle(DrawTrSurf_Curve2d)::DownCast(d);
1531 GeomTools_Curve2dSet::PrintCurve2d(N->GetCurve(),OS,Standard_True);
1532}
1533
1534static Handle(Draw_Drawable3D) c2drestore (istream& is)
1535{
1536 Handle(Geom2d_Curve) G;
1537 GeomTools_Curve2dSet::ReadCurve2d(is,G);
1538 Handle(DrawTrSurf_Curve2d) N =
1539 new DrawTrSurf_Curve2d(G,CurvColor,Discret);
1540 return N;
1541}
1542
1543
1544static Draw_SaveAndRestore c2dsr("DrawTrSurf_Curve2d",
1545 c2dtest,c2dsave,c2drestore);
1546
1547
1548
1549
1550//=================================================================
1551// save and restore bezier curves 2d
1552//=================================================================
1553
1554static Standard_Boolean bzc2dtest(const Handle(Draw_Drawable3D)& d)
1555{
1556 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BezierCurve2d));
1557}
1558
1559static void bzc2dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1560{
1561 Handle(DrawTrSurf_BezierCurve2d)
1562 N = Handle(DrawTrSurf_BezierCurve2d)::DownCast(d);
1563 GeomTools_Curve2dSet::PrintCurve2d(N->GetCurve(),OS,Standard_True);
1564}
1565
1566static Handle(Draw_Drawable3D) bzc2drestore (istream& is)
1567{
1568 Handle(Geom2d_BezierCurve) G;
1569 GeomTools_Curve2dSet::ReadCurve2d(is,G);
1570 Handle(DrawTrSurf_BezierCurve2d) N =
1571 new DrawTrSurf_BezierCurve2d(G,CurvColor,PolesColor,ShowPoles,
1572 Discret);
1573 return N;
1574}
1575
1576
1577static Draw_SaveAndRestore bzc2dsr("DrawTrSurf_BezierCurve2d",
1578 bzc2dtest,bzc2dsave,bzc2drestore);
1579
1580
1581
1582
1583//=================================================================
1584// save and restore bspline curves 2d
1585//=================================================================
1586
1587static Standard_Boolean bsc2dtest(const Handle(Draw_Drawable3D)& d)
1588{
1589 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BSplineCurve2d));
1590}
1591
1592static void bsc2dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1593{
1594 Handle(DrawTrSurf_BSplineCurve2d)
1595 N = Handle(DrawTrSurf_BSplineCurve2d)::DownCast(d);
1596 GeomTools_Curve2dSet::PrintCurve2d(N->GetCurve(),OS,Standard_True);
1597}
1598
1599static Handle(Draw_Drawable3D) bsc2drestore (istream& is)
1600{
1601 Handle(Geom2d_BSplineCurve) G;
1602 GeomTools_Curve2dSet::ReadCurve2d(is,G);
1603 Handle(DrawTrSurf_BSplineCurve2d) N =
1604 new DrawTrSurf_BSplineCurve2d(G, CurvColor,PolesColor,
1605 KnotsColor,
1606 KnotsShape,KnotsSize,
1607 ShowPoles,ShowKnots,
1608 Discret);
1609 return N;
1610}
1611
1612
1613static Draw_SaveAndRestore bsc2dsr("DrawTrSurf_BSplineCurve2d",
1614 bsc2dtest,bsc2dsave,bsc2drestore);
1615
1616
1617//=================================================================
1618// save and restore surfaces
1619//=================================================================
1620
1621static Standard_Boolean stest(const Handle(Draw_Drawable3D)& d)
1622{
1623 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Surface));
1624}
1625
1626static void ssave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1627{
1628 Handle(DrawTrSurf_Surface) N = Handle(DrawTrSurf_Surface)::DownCast(d);
1629 GeomTools_SurfaceSet::PrintSurface(N->GetSurface(),OS,Standard_True);
1630}
1631
1632static Handle(Draw_Drawable3D) srestore (istream& is)
1633{
1634 Handle(Geom_Surface) G;
1635 GeomTools_SurfaceSet::ReadSurface(is,G);
1636 Handle(DrawTrSurf_Surface) N =
1637 new DrawTrSurf_Surface(G,
1638 NbUIsos,NbVIsos,
1639 BoundsColor,IsosColor,
1640 Discret,Deflection,DrawMode);
1641 return N;
1642}
1643
1644
1645static Draw_SaveAndRestore ssr("DrawTrSurf_Surface",
1646 stest,ssave,srestore);
1647
1648
1649
1650
1651//=================================================================
1652// save and restore bezier surfaces
1653//=================================================================
1654
1655static Standard_Boolean bzstest(const Handle(Draw_Drawable3D)& d)
1656{
1657 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BezierSurface));
1658}
1659
1660static void bzssave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1661{
1662 Handle(DrawTrSurf_BezierSurface)
1663 N = Handle(DrawTrSurf_BezierSurface)::DownCast(d);
1664 GeomTools_SurfaceSet::PrintSurface(N->GetSurface(),OS,Standard_True);
1665}
1666
1667static Handle(Draw_Drawable3D) bzsrestore (istream& is)
1668{
1669 Handle(Geom_BezierSurface) G;
1670 GeomTools_SurfaceSet::ReadSurface(is,G);
1671 Handle(DrawTrSurf_BezierSurface) N =
1672 new DrawTrSurf_BezierSurface(G,NbUIsos,NbVIsos,
1673 BoundsColor,IsosColor,PolesColor,
1674 ShowPoles,
1675 Discret,Deflection,DrawMode);
1676 return N;
1677}
1678
1679
1680static Draw_SaveAndRestore bzssr("DrawTrSurf_BezierSurface",
1681 bzstest,bzssave,bzsrestore);
1682
1683
1684
1685
1686//=================================================================
1687// save and restore bspline surfaces
1688//=================================================================
1689
1690static Standard_Boolean bsstest(const Handle(Draw_Drawable3D)& d)
1691{
1692 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_BSplineSurface));
1693}
1694
1695static void bsssave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1696{
1697 Handle(DrawTrSurf_BSplineSurface)
1698 N = Handle(DrawTrSurf_BSplineSurface)::DownCast(d);
1699 GeomTools_SurfaceSet::PrintSurface(N->GetSurface(),OS,Standard_True);
1700}
1701
1702static Handle(Draw_Drawable3D) bssrestore (istream& is)
1703{
1704 Handle(Geom_BSplineSurface) G;
1705 GeomTools_SurfaceSet::ReadSurface(is,G);
1706 Handle(DrawTrSurf_BSplineSurface) N;
1707 if (!knotsIsos)
1708 N = new DrawTrSurf_BSplineSurface(G,
1709 NbUIsos,NbVIsos,
1710 BoundsColor,IsosColor,
1711 PolesColor,KnotsColor,
1712 KnotsShape,KnotsSize,
1713 ShowPoles,ShowKnots,
1714 Discret,Deflection,DrawMode);
1715 else
1716 N = new DrawTrSurf_BSplineSurface(G,
1717 BoundsColor,IsosColor,
1718 PolesColor,KnotsColor,
1719 KnotsShape,KnotsSize,
1720 ShowPoles,ShowKnots,
1721 Discret,Deflection,DrawMode);
1722
1723 return N;
1724}
1725
1726
1727static Draw_SaveAndRestore bsssr("DrawTrSurf_BSplineSurface",
1728 bsstest,bsssave,bssrestore);
1729
1730
1731//=================================================================
1732// save and restore points
1733//=================================================================
1734
1735static Standard_Boolean pnttest(const Handle(Draw_Drawable3D)& d)
1736{
1737 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Point));
1738}
1739
1740static void pntsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1741{
1742 Handle(DrawTrSurf_Point)
1743 N = Handle(DrawTrSurf_Point)::DownCast(d);
1744#if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1745 ios::fmtflags F = OS.flags();
1746 OS.setf(ios::scientific,ios::floatfield);
1747 OS.precision(15);
1748#else
1749 long form = OS.setf(ios::scientific);
60be1f9b 1750 std::streamsize prec = OS.precision(15);
7fd59977 1751#endif
1752 gp_Pnt P = N->Point();
1753 if (N->Is3D()) {
1754 OS << "1 ";
1755 OS << P.X() << " " << P.Y() << " " << P.Z() << "\n";
1756 }
1757 else {
1758 OS << "0 ";
1759 OS << P.X() << " " << P.Y() << "\n";
1760 }
1761#if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1762 OS.setf(F);
1763#else
1764 OS.setf(form);
1765 OS.precision(prec);
1766#endif
1767}
1768
1769static Handle(Draw_Drawable3D) pntrestore (istream& is)
1770{
1771 Standard_Integer is3d;
1772 is >> is3d;
1d47d8d0 1773 Standard_Real x,y,z = 0.;
7fd59977 1774 if (is3d)
1775 is >> x >> y >> z;
1776 else
1777 is >> x >> y;
1778 Handle(DrawTrSurf_Point) N;
1779 if (is3d)
1780 N = new DrawTrSurf_Point(gp_Pnt(x,y,z),PntShape,PntColor);
1781 else
1782 N = new DrawTrSurf_Point(gp_Pnt2d(x,y),PntShape,PntColor);
1783
1784 return N;
1785}
1786
1787
1788static Draw_SaveAndRestore pntsr("DrawTrSurf_Point",
1789 pnttest,pntsave,pntrestore);
1790
1791
1792
1793//=================================================================
1794// save and restore triangulation
1795//=================================================================
1796
1797static Standard_Boolean triatest(const Handle(Draw_Drawable3D)& d)
1798{
1799 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Triangulation));
1800}
1801
1802static void triasave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1803{
1804 Handle(DrawTrSurf_Triangulation)
1805 T = Handle(DrawTrSurf_Triangulation)::DownCast(d);
1806#if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1807 ios::fmtflags F = OS.flags();
1808 OS.setf(ios::scientific,ios::floatfield);
1809 OS.precision(15);
1810#else
1811 long form = OS.setf(ios::scientific);
60be1f9b 1812 std::streamsize prec = OS.precision(15);
7fd59977 1813#endif
1814 Poly::Write(T->Triangulation(),OS);
1815#if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1816 OS.setf(F);
1817#else
1818 OS.setf(form);
1819 OS.precision(prec);
1820#endif
1821}
1822
1823static Handle(Draw_Drawable3D) triarestore (istream& is)
1824{
1825 return new DrawTrSurf_Triangulation(Poly::ReadTriangulation(is));
1826}
1827
1828
1829static Draw_SaveAndRestore triasr("DrawTrSurf_Triangulation",
1830 triatest,triasave,triarestore);
1831
1832
1833
1834//=================================================================
1835// save and restore polygon3d
1836//=================================================================
1837
1838static Standard_Boolean poly3dtest(const Handle(Draw_Drawable3D)& d)
1839{
1840 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Polygon3D));
1841}
1842
1843static void poly3dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1844{
1845 Handle(DrawTrSurf_Polygon3D)
1846 T = Handle(DrawTrSurf_Polygon3D)::DownCast(d);
1847#if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1848 ios::fmtflags F = OS.flags();
1849 OS.setf(ios::scientific,ios::floatfield);
1850 OS.precision(15);
1851#else
1852 long form = OS.setf(ios::scientific);
60be1f9b 1853 std::streamsize prec = OS.precision(15);
7fd59977 1854#endif
1855 Poly::Write(T->Polygon3D(),OS);
1856#if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1857 OS.setf(F);
1858#else
1859 OS.setf(form);
1860 OS.precision(prec);
1861#endif
1862}
1863
1864static Handle(Draw_Drawable3D) poly3drestore (istream& is)
1865{
1866 return new DrawTrSurf_Polygon3D(Poly::ReadPolygon3D(is));
1867}
1868
1869
1870static Draw_SaveAndRestore poly3dsr("DrawTrSurf_Polygon3D",
1871 poly3dtest,poly3dsave,poly3drestore);
1872
1873
1874//=================================================================
1875// save and restore polygon2d
1876//=================================================================
1877
1878static Standard_Boolean poly2dtest(const Handle(Draw_Drawable3D)& d)
1879{
1880 return d->IsInstance(STANDARD_TYPE(DrawTrSurf_Polygon2D));
1881}
1882
1883static void poly2dsave(const Handle(Draw_Drawable3D)&d, ostream& OS)
1884{
1885 Handle(DrawTrSurf_Polygon2D)
1886 T = Handle(DrawTrSurf_Polygon2D)::DownCast(d);
1887#if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1888 ios::fmtflags F = OS.flags();
1889 OS.setf(ios::scientific, ios::floatfield);
1890 OS.precision(15);
1891#else
1892 long form = OS.setf(ios::scientific);
60be1f9b 1893 std::streamsize prec = OS.precision(15);
7fd59977 1894#endif
1895 Poly::Write(T->Polygon2D(),OS);
1896#if defined(HAVE_IOS) && !defined(__sgi) && !defined(IRIX)
1897 OS.setf(F);
1898#else
1899 OS.setf(form);
1900 OS.precision(prec);
1901#endif
1902}
1903
1904static Handle(Draw_Drawable3D) poly2drestore (istream& is)
1905{
1906 return new DrawTrSurf_Polygon2D(Poly::ReadPolygon2D(is));
1907}
1908
1909
1910static Draw_SaveAndRestore poly2dsr("DrawTrSurf_Polygon2D",
1911 poly2dtest,poly2dsave,poly2drestore);
1912