src/DrawTrSurf/DrawTrSurf.cxx

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