src/GeomliteTest/GeomliteTest_CurveCommands.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 under
   9 // the terms of the GNU Lesser General Public License 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 // Modified by xab, Tue Mar 11 18:31:18 1997
  18 // Modified by PMN 14/04/97 : Passage a Geomlite
  19 // Modified by JPI 01/08/97 : ajout de la commande approxcurve
  20
  21 #include <GeomliteTest.hxx>
  22 #include <Draw_Appli.hxx>
  23 #include <DrawTrSurf.hxx>
  24 #include <DrawTrSurf_Curve.hxx>
  25 #include <DrawTrSurf_Curve2d.hxx>
  26 #include <DrawTrSurf_BezierCurve.hxx>
  27 #include <DrawTrSurf_BSplineCurve.hxx>
  28 #include <DrawTrSurf_BezierCurve2d.hxx>
  29 #include <DrawTrSurf_BSplineCurve2d.hxx>
  30 #include <Draw_Marker3D.hxx>
  31 #include <Draw_Marker2D.hxx>
  32 #include <Draw.hxx>
  33 #include <Draw_Interpretor.hxx>
  34 #include <Draw_Color.hxx>
  35 #include <Draw_Display.hxx>
  36
  37 #include <BSplCLib.hxx>
  38
  39 #include <gp.hxx>
  40 #include <gp_Pln.hxx>
  41 #include <gp_Parab2d.hxx>
  42 #include <gp_Elips2d.hxx>
  43 #include <gp_Hypr2d.hxx>
  44
  45 #include <Geom_Line.hxx>
  46 #include <Geom_Circle.hxx>
  47 #include <Geom_Ellipse.hxx>
  48 #include <Geom_Parabola.hxx>
  49 #include <Geom_Hyperbola.hxx>
  50 #include <Geom_BezierCurve.hxx>
  51 #include <Geom_BSplineCurve.hxx>
  52 #include <GeomAdaptor_Surface.hxx>
  53 #include <GeomAdaptor_HSurface.hxx>
  54
  55 #include <GeomLib.hxx>
  56 #include <GeomConvert.hxx>
  57 #include <Geom2dConvert.hxx>
  58
  59 #include <Geom2d_Line.hxx>
  60 #include <Geom2d_Circle.hxx>
  61 #include <Geom2d_Ellipse.hxx>
  62 #include <Geom2d_Parabola.hxx>
  63 #include <Geom2d_Hyperbola.hxx>
  64 #include <Geom2d_BezierCurve.hxx>
  65 #include <Geom2d_BSplineCurve.hxx>
  66
  67 #include <GeomLProp.hxx>
  68 #include <GeomLProp_CLProps.hxx>
  69 #include <Geom2dLProp_CLProps2d.hxx>
  70 #include <Geom2dLProp_CurAndInf2d.hxx>
  71
  72 #include <TColgp_Array1OfPnt.hxx>
  73 #include <TColgp_Array1OfPnt2d.hxx>
  74 #include <TColStd_Array1OfReal.hxx>
  75 #include <TColStd_Array1OfInteger.hxx>
  76
  77 #include <GeomAbs_SurfaceType.hxx>
  78 #include <GeomAbs_CurveType.hxx>
  79
  80 #include <Precision.hxx>
  81
  82 #include <stdio.h>
  83
  84 #include <TColStd_HArray1OfReal.hxx>
  85 #include <TColStd_HArray2OfReal.hxx>
  86 #include <TColStd_HArray1OfInteger.hxx>
  87 #include <TColStd_Array1OfReal.hxx>
  88 #include <TColStd_Array1OfInteger.hxx>
  89
  90 #include <TColGeom_HArray1OfBSplineCurve.hxx>
  91 #include <TColGeom2d_HArray1OfBSplineCurve.hxx>
  92 #include <Convert_CompPolynomialToPoles.hxx>
  93 #include <CPnts_AbscissaPoint.hxx>
  94 #include <GCPnts_AbscissaPoint.hxx>
  95
  96 #include <PLib.hxx>
  97 #include <GeomAbs_Shape.hxx>
  98 #include <Geom_Curve.hxx>
  99 #include <GeomConvert.hxx>
 100 #include <GeomConvert_ApproxCurve.hxx>
 101 #include <Geom2dConvert_ApproxCurve.hxx>
 102 #include <Geom2d_Curve.hxx>
 103
 104 #include <GeomAdaptor_HCurve.hxx>
 105 #include <GeomAdaptor_Curve.hxx>
 106 #include <Geom2dAdaptor_HCurve.hxx>
 107 #include <GeomAdaptor_HCurve.hxx>
 108 #include <Approx_CurvilinearParameter.hxx>
 109 #include <Approx_CurveOnSurface.hxx>
 110 #include <Geom_BSplineSurface.hxx>
 111 #ifdef WNT
 112 Standard_IMPORT Draw_Viewer dout;
 113 #endif
 114
 115 //=======================================================================
 116 //function : anacurve
 117 //purpose  :
 118 //=======================================================================
 119
 120 static Standard_Integer anacurve (Draw_Interpretor& , Standard_Integer n, const char** a)
 121 {
 122   if (n < 5) return 1;
 123
 124   Handle(Geom_Geometry) result;
 125   Handle(Geom2d_Curve)  result2d;
 126
 127   if (!strcmp(a[0],"line")) {
 128     if (n == 6)
 129       result2d = new Geom2d_Line(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 130                                  gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5])));
 131     else if (n == 8)
 132       result = new Geom_Line(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 133                              gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])));
 134     else
 135       return 1;
 136   }
 137
 138   else if (!strcmp(a[0],"circle")) {
 139     if (n == 5)
 140       result2d =
 141         new Geom2d_Circle(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 142                                    gp_Dir2d(1,0)),
 143                           Draw::Atof(a[4]));
 144     else if (n == 6)
 145       result =
 146         new Geom_Circle(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 147                                gp_Dir(0,0,1)),
 148                         Draw::Atof(a[5]));
 149     else if (n == 7)
 150       result2d =
 151         new Geom2d_Circle(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 152                                    gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))),
 153                           Draw::Atof(a[6]));
 154     else if (n == 9)
 155       result =
 156         new Geom_Circle(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 157                                gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))),
 158                         Draw::Atof(a[8]));
 159     else if (n == 12)
 160       result =
 161         new Geom_Circle(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 162                                gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])),
 163                                gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10]))),
 164                         Draw::Atof(a[11]));
 165     else
 166       return 1;
 167   }
 168
 169   else if (!strcmp(a[0],"parabola")) {
 170     if (n == 5)
 171       result2d =
 172         new Geom2d_Parabola(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 173                                      gp_Dir2d(1,0)),
 174                             Draw::Atof(a[4]));
 175     else if (n == 6)
 176       result =
 177         new Geom_Parabola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 178                                  gp_Dir(0,0,1)),
 179                           Draw::Atof(a[5]));
 180     else if (n == 7)
 181       result2d =
 182         new Geom2d_Parabola(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 183                                      gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))),
 184                             Draw::Atof(a[6]));
 185     else if (n == 9)
 186       result =
 187         new Geom_Parabola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 188                                  gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))),
 189                           Draw::Atof(a[8]));
 190     else if (n == 12)
 191       result =
 192         new Geom_Parabola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 193                                  gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])),
 194                                  gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10]))),
 195                           Draw::Atof(a[11]));
 196     else
 197       return 1;
 198   }
 199
 200   else if (!strcmp(a[0],"ellipse")) {
 201     if (n == 6)
 202       result2d =
 203         new Geom2d_Ellipse(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 204                                     gp_Dir2d(1,0)),
 205                            Draw::Atof(a[4]),Draw::Atof(a[5]));
 206     else if (n == 7)
 207       result =
 208         new Geom_Ellipse(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 209                                 gp_Dir(0,0,1)),
 210                          Draw::Atof(a[5]),Draw::Atof(a[6]));
 211     else if (n == 8)
 212       result2d =
 213         new Geom2d_Ellipse(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 214                                     gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))),
 215                            Draw::Atof(a[6]), Draw::Atof(a[7]));
 216     else if (n == 10)
 217       result =
 218         new Geom_Ellipse(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 219                                 gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))),
 220                          Draw::Atof(a[8]), Draw::Atof(a[9]));
 221     else if (n == 13)
 222       result =
 223         new Geom_Ellipse(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 224                                 gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])),
 225                                 gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10]))),
 226                          Draw::Atof(a[11]), Draw::Atof(a[12]));
 227     else
 228       return 1;
 229   }
 230
 231   else if (!strcmp(a[0],"hyperbola")) {
 232     if (n == 6)
 233       result2d =
 234         new Geom2d_Hyperbola(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 235                                       gp_Dir2d(1,0)),
 236                              Draw::Atof(a[4]),Draw::Atof(a[5]));
 237     else if (n == 7)
 238       result =
 239         new Geom_Hyperbola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 240                                   gp_Dir(0,0,1)),
 241                            Draw::Atof(a[5]),Draw::Atof(a[6]));
 242     else if (n == 8)
 243       result2d =
 244         new Geom2d_Hyperbola(gp_Ax22d(gp_Pnt2d(Draw::Atof(a[2]),Draw::Atof(a[3])),
 245                                       gp_Dir2d(Draw::Atof(a[4]),Draw::Atof(a[5]))),
 246                              Draw::Atof(a[6]), Draw::Atof(a[7]));
 247     else if (n == 10)
 248       result =
 249         new Geom_Hyperbola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 250                                   gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]))),
 251                            Draw::Atof(a[8]), Draw::Atof(a[9]));
 252     else if (n == 13)
 253       result =
 254         new Geom_Hyperbola(gp_Ax2(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
 255                                   gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])),
 256                                   gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10]))),
 257                            Draw::Atof(a[11]), Draw::Atof(a[12]));
 258     else
 259       return 1;
 260   }
 261
 262   if (!result.IsNull())
 263     DrawTrSurf::Set(a[1],result);
 264   else if (!result2d.IsNull())
 265     DrawTrSurf::Set(a[1],result2d);
 266   else
 267     return 1;
 268
 269   return 0;
 270 }
 271
 272 //=======================================================================
 273 //function : polecurve
 274 //purpose  :
 275 //=======================================================================
 276
 277 static Standard_Integer polecurve (Draw_Interpretor& , Standard_Integer n, const char** a)
 278 {
 279   Standard_Integer k,i;
 280
 281
 282   if (n < 3) return 1;
 283
 284   if (!strcmp(a[0],"beziercurve")) {
 285
 286     Standard_Integer np = Draw::Atoi(a[2]);
 287     if (np == 0) return 1;
 288
 289     i = (n - 3) / (np);
 290     if (i < 3 || i > 4) return 1;
 291     Standard_Boolean hasw = i == 4;
 292
 293     TColgp_Array1OfPnt poles(1,np);
 294     TColStd_Array1OfReal weights(1,np);
 295
 296     k = 3;
 297     for (i = 1; i <= np; i++) {
 298       poles(i).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1]),Draw::Atof(a[k+2]));
 299       k += 3;
 300       if (hasw) {
 301         weights(i) = Draw::Atof(a[k]);
 302         k++;
 303       }
 304     }
 305
 306     Handle(Geom_BezierCurve) result;
 307     if (hasw)
 308       result = new Geom_BezierCurve(poles,weights);
 309     else
 310       result = new Geom_BezierCurve(poles);
 311
 312     DrawTrSurf::Set(a[1],result);
 313   }
 314
 315   else if (!strcmp((*a[0] == 'p') ? a[0]+1 : a[0],"bsplinecurve")) {
 316     Standard_Integer deg = Draw::Atoi(a[2]);
 317     Standard_Integer nbk = Draw::Atoi(a[3]);
 318
 319     TColStd_Array1OfReal    knots(1, nbk);
 320     TColStd_Array1OfInteger mults(1, nbk);
 321     k = 4;
 322     Standard_Integer Sigma = 0;
 323     for (i = 1; i<=nbk; i++) {
 324       knots( i) = Draw::Atof(a[k]);
 325       k++;
 326       mults( i) = Draw::Atoi(a[k]);
 327       Sigma += mults(i);
 328       k++;
 329     }
 330
 331     Standard_Boolean periodic = *a[0] == 'p';
 332     Standard_Integer np;
 333     if (periodic)
 334       np = Sigma - mults(nbk);
 335     else
 336       np = Sigma - deg  -1;
 337
 338     TColgp_Array1OfPnt   poles  (1, np);
 339     TColStd_Array1OfReal weights(1, np);
 340
 341     for (i = 1; i <= np; i++) {
 342       poles(i).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1]),Draw::Atof(a[k+2]));
 343       k += 3;
 344       weights(i) = Draw::Atof(a[k]);
 345       k++;
 346     }
 347
 348     Handle(Geom_BSplineCurve) result =
 349       new Geom_BSplineCurve(poles, weights, knots, mults, deg, periodic);
 350     DrawTrSurf::Set(a[1],result);
 351   }
 352
 353   return 0;
 354 }
 355
 356 //=======================================================================
 357 //function : polecurve2d
 358 //purpose  :
 359 //=======================================================================
 360
 361 static Standard_Integer polecurve2d (Draw_Interpretor& , Standard_Integer n, const char** a)
 362 {
 363   Standard_Integer k,i;
 364
 365
 366   if (n < 3) return 1;
 367
 368   if (!strcmp(a[0],"2dbeziercurve")) {
 369
 370     Standard_Integer np = Draw::Atoi(a[2]);
 371     if (np == 0) return 1;
 372
 373     i = (n - 2) / (np);
 374     if (i < 2 || i > 3) return 1;
 375     Standard_Boolean hasw = i == 3;
 376
 377     TColgp_Array1OfPnt2d poles(1,np);
 378     TColStd_Array1OfReal weights(1,np);
 379
 380     k = 3;
 381     for (i = 1; i <= np; i++) {
 382       poles(i).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1]));
 383       k += 2;
 384       if (hasw) {
 385         weights(i) = Draw::Atof(a[k]);
 386         k++;
 387       }
 388     }
 389
 390     Handle(Geom2d_BezierCurve) result;
 391     if (hasw)
 392       result = new Geom2d_BezierCurve(poles,weights);
 393     else
 394       result = new Geom2d_BezierCurve(poles);
 395
 396     DrawTrSurf::Set(a[1],result);
 397   }
 398
 399   else if (!strcmp((*(a[0]+2) == 'p') ? a[0]+3 : a[0]+2,"bsplinecurve")) {
 400     Standard_Integer deg = Draw::Atoi(a[2]);
 401     Standard_Integer nbk = Draw::Atoi(a[3]);
 402
 403     TColStd_Array1OfReal    knots(1, nbk);
 404     TColStd_Array1OfInteger mults(1, nbk);
 405     k = 4;
 406     Standard_Integer Sigma = 0;
 407     for (i = 1; i<=nbk; i++) {
 408       knots( i) = Draw::Atof(a[k]);
 409       k++;
 410       mults( i) = Draw::Atoi(a[k]);
 411       Sigma += mults(i);
 412       k++;
 413     }
 414
 415     Standard_Boolean periodic = *(a[0]+2) == 'p';
 416     Standard_Integer np;
 417     if (periodic)
 418       np = Sigma - mults(nbk);
 419     else
 420       np = Sigma - deg  -1;
 421
 422     TColgp_Array1OfPnt2d poles  (1, np);
 423     TColStd_Array1OfReal weights(1, np);
 424
 425     for (i = 1; i <= np; i++) {
 426       poles(i).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1]));
 427       k += 2;
 428       weights(i) = Draw::Atof(a[k]);
 429       k++;
 430     }
 431
 432     Handle(Geom2d_BSplineCurve) result =
 433       new Geom2d_BSplineCurve(poles, weights, knots, mults, deg, periodic);
 434     DrawTrSurf::Set(a[1],result);
 435   }
 436
 437   return 0;
 438 }
 439
 440 //=======================================================================
 441 //function : reverse
 442 //purpose  :
 443 //=======================================================================
 444
 445 static Standard_Integer reverse (Draw_Interpretor& , Standard_Integer n, const char** a)
 446 {
 447   if (n < 2) return 1;
 448
 449   Standard_Integer i;
 450   for (i = 1; i < n; i++) {
 451
 452     Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[i]);
 453     if (!GC.IsNull()) {
 454       GC->Reverse();
 455       Draw::Repaint();
 456     }
 457     Handle(Geom2d_Curve) GC2d = DrawTrSurf::GetCurve2d(a[i]);
 458     if (!GC2d.IsNull()) {
 459       GC2d->Reverse();
 460       Draw::Repaint();
 461     }
 462   }
 463   return 0;
 464 }
 465
 466 //=======================================================================
 467 //function : cmovepole
 468 //purpose  :
 469 //=======================================================================
 470
 471 static Standard_Integer cmovepole (Draw_Interpretor& , Standard_Integer n, const char** a)
 472 {
 473   if (n < 5) return 1;
 474
 475   Standard_Real dx = Draw::Atof(a[3]);
 476   Standard_Real dy = Draw::Atof(a[4]);
 477   Standard_Real dz=0;
 478   if (n >= 6) dz = Draw::Atof(a[5]);
 479   Standard_Integer Index = Draw::Atoi(a[2]);
 480
 481   Handle(Geom_BezierCurve) G1 = DrawTrSurf::GetBezierCurve(a[1]);
 482   if (!G1.IsNull()) {
 483     gp_Pnt P = G1->Pole(Index);
 484     P.SetCoord(P.X()+dx, P.Y()+dy, P.Z()+dz);
 485     G1->SetPole(Index,P);
 486     Draw::Repaint();
 487     return 0;
 488   }
 489
 490
 491   Handle(Geom_BSplineCurve) G2 = DrawTrSurf::GetBSplineCurve(a[1]);
 492   if (!G2.IsNull()) {
 493     gp_Pnt P = G2->Pole(Index);
 494     P.SetCoord(P.X()+dx, P.Y()+dy, P.Z()+dz);
 495     G2->SetPole(Index,P);
 496     Draw::Repaint();
 497     return 0;
 498   }
 499
 500   Handle(Geom2d_BezierCurve) G3 = DrawTrSurf::GetBezierCurve2d(a[1]);
 501   if (!G3.IsNull()) {
 502     gp_Pnt2d P = G3->Pole(Index);
 503     P.SetCoord(P.X()+dx, P.Y()+dy);
 504     G3->SetPole(Index,P);
 505     Draw::Repaint();
 506     return 0;
 507   }
 508
 509
 510   Handle(Geom2d_BSplineCurve) G4 = DrawTrSurf::GetBSplineCurve2d(a[1]);
 511   if (!G4.IsNull()) {
 512     gp_Pnt2d P = G4->Pole(Index);
 513     P.SetCoord(P.X()+dx, P.Y()+dy);
 514     G4->SetPole(Index,P);
 515     Draw::Repaint();
 516     return 0;
 517   }
 518
 519
 520
 521   return 0;
 522 }
 523
 524 //=======================================================================
 525 //function : cmovetangent
 526 //purpose  :
 527 //=======================================================================
 528
 529 static Standard_Integer cmovetangent (Draw_Interpretor& di, Standard_Integer n, const char** a)
 530 {
 531   Standard_Integer dimension,
 532   condition,
 533   error_status ;
 534   Standard_Real u,
 535   x,
 536   y,
 537   z,
 538   tolerance,
 539   tx,
 540   ty,
 541   tz ;
 542   u = Draw::Atof(a[2]);
 543   x = Draw::Atof(a[3]);
 544   y = Draw::Atof(a[4]);
 545   z = 0.0e0,
 546   tolerance = 1.0e-5 ;
 547   dimension = 3 ;
 548   if (n <= 8) {
 549     dimension = 2 ;
 550     if (n < 7) {
 551       return 1 ;
 552     }
 553   }
 554   else {
 555     dimension = 3 ;
 556     if (n < 9) {
 557       return 1 ;
 558     }
 559   }
 560   condition = 0 ;
 561   error_status  = 0 ;
 562   if (dimension == 3) {
 563     Handle(Geom_BSplineCurve) G2 = DrawTrSurf::GetBSplineCurve(a[1]);
 564     if (!G2.IsNull()) {
 565       z  = Draw::Atof(a[5]) ;
 566       tx = Draw::Atof(a[6]) ;
 567       ty = Draw::Atof(a[7]) ;
 568       tz = Draw::Atof(a[8]) ;
 569       if (n == 10) {
 570         condition = Max(Draw::Atoi(a[9]), -1)  ;
 571         condition = Min(condition, G2->Degree()-1) ;
 572       }
 573       gp_Pnt p;
 574       gp_Vec tangent ;
 575       p.SetCoord(x,y,z);
 576       tangent.SetCoord(tx,ty,tz) ;
 577
 578       G2->MovePointAndTangent(u,
 579                               p,
 580                               tangent,
 581                               tolerance,
 582                               condition,
 583                               condition,
 584                               error_status) ;
 585       if (! error_status) {
 586         Draw::Repaint();
 587         }
 588       else {
 589         di << "Not enought degree of freedom increase degree please" << "\n";
 590       }
 591
 592       return 0;
 593     }
 594   }
 595   else {
 596     Handle(Geom2d_BSplineCurve) G2 = DrawTrSurf::GetBSplineCurve2d(a[1]);
 597     if (!G2.IsNull()) {
 598       tx = Draw::Atof(a[5]) ;
 599       ty = Draw::Atof(a[6]) ;
 600       if (n == 8) {
 601         condition = Max(Draw::Atoi(a[7]), -1)  ;
 602         condition = Min(condition, G2->Degree()-1) ;
 603       }
 604       gp_Pnt2d p;
 605       gp_Vec2d tangent ;
 606       p.SetCoord(x,y);
 607       tangent.SetCoord(tx,ty) ;
 608
 609       G2->MovePointAndTangent(u,
 610                               p,
 611                               tangent,
 612                               tolerance,
 613                               condition,
 614                               condition,
 615                               error_status) ;
 616       if (! error_status) {
 617         Draw::Repaint();
 618         }
 619       else {
 620         di << "Not enought degree of freedom increase degree please" << "\n";
 621       }
 622
 623       return 0;
 624     }
 625    }
 626   return 0;
 627 }
 628
 629
 630 //=======================================================================
 631 //function : cmovepoint
 632 //purpose  :
 633 //=======================================================================
 634
 635 static Standard_Integer cmovepoint (Draw_Interpretor& , Standard_Integer n, const char** a)
 636 {
 637   if (n < 5) return 1;
 638
 639   Standard_Real dx = Draw::Atof(a[3]);
 640   Standard_Real dy = Draw::Atof(a[4]);
 641   Standard_Real dz=0;
 642   if (n >= 6 && n != 7) dz = Draw::Atof(a[5]);
 643   Standard_Real u = Draw::Atof(a[2]);
 644   Standard_Integer index1 = 0;
 645   Standard_Integer index2 = 0;
 646   Standard_Integer fmodif, lmodif;
 647   if (n == 7) {
 648     index1 = Draw::Atoi(a[5]);
 649     index2 = Draw::Atoi(a[6]);
 650   }
 651   else if (n == 8) {
 652     index1 = Draw::Atoi(a[6]);
 653     index2 = Draw::Atoi(a[7]);
 654   }
 655
 656   Handle(Geom_BSplineCurve) G2 = DrawTrSurf::GetBSplineCurve(a[1]);
 657   if (!G2.IsNull()) {
 658     if (index1 == 0) {
 659       index1 = 2;
 660       index2 = G2->NbPoles()-1;
 661     }
 662     gp_Pnt p;
 663     G2->D0(u, p);
 664     p.SetCoord(p.X()+dx, p.Y()+dy, p.Z()+dz);
 665     G2->MovePoint(u, p, index1, index2, fmodif, lmodif);
 666     Draw::Repaint();
 667     return 0;
 668   }
 669
 670   Handle(Geom2d_BSplineCurve) G4 = DrawTrSurf::GetBSplineCurve2d(a[1]);
 671   if (!G4.IsNull()) {
 672     if (index1 == 0) {
 673       index1 = 2;
 674       index2 = G4->NbPoles()-1;
 675     }
 676     gp_Pnt2d p;
 677     G4->D0(u, p);
 678     p.SetCoord(p.X()+dx, p.Y()+dy);
 679     G4->MovePoint(u, p, index1, index2, fmodif, lmodif);
 680     Draw::Repaint();
 681     return 0;
 682   }
 683   return 0;
 684 }
 685
 686 //=======================================================================
 687 //function : cinsertknot
 688 //purpose  :
 689 //=======================================================================
 690
 691 static Standard_Integer cinsertknot (Draw_Interpretor& , Standard_Integer n, const char** a)
 692 {
 693   if (n < 4) return 1;
 694
 695   Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]);
 696   Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]);
 697
 698   if (GBs.IsNull() && GBs2d.IsNull()) return 1;
 699
 700   if (n <= 4) {
 701     Standard_Real    knot = Draw::Atof(a[2]);
 702     Standard_Integer mult = 1;
 703     if (n == 4) mult = Draw::Atoi(a[3]);
 704     if (!GBs.IsNull())
 705       GBs->InsertKnot(knot,mult,Precision::PConfusion());
 706     else
 707       GBs2d->InsertKnot(knot,mult,Precision::PConfusion());
 708   }
 709
 710   else {
 711     // multiple insertion
 712     if (n % 2 != 0) return 1;
 713     Standard_Integer i,nbk = (n-2) / 2;
 714     TColStd_Array1OfReal    knots(1,nbk);
 715     TColStd_Array1OfInteger mults(1,nbk);
 716     for (i = 2; i < n; i += 2) {
 717       knots(i/2) = Draw::Atof(a[i]);
 718       mults(i/2) = Draw::Atoi(a[i+1]);
 719     }
 720
 721     if (!GBs.IsNull())
 722       GBs->InsertKnots(knots,mults,Precision::PConfusion());
 723     else
 724       GBs2d->InsertKnots(knots,mults,Precision::PConfusion());
 725
 726   }
 727
 728   Draw::Repaint();
 729   return 0;
 730 }
 731
 732 //=======================================================================
 733 //function : csetknot
 734 //purpose  :
 735 //=======================================================================
 736
 737 static Standard_Integer csetknot (Draw_Interpretor& , Standard_Integer n, const char** a)
 738 {
 739   if (n < 4) return 1;
 740
 741   Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]);
 742   Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]);
 743
 744   if (GBs.IsNull() && GBs2d.IsNull()) return 1;
 745
 746   Standard_Integer index = Draw::Atoi(a[2]);
 747   Standard_Real    knot  = Draw::Atof(a[3]);
 748
 749   if ( n == 4) {
 750     if (!GBs.IsNull())
 751       GBs->SetKnot(index,knot);
 752     else
 753       GBs2d->SetKnot(index,knot);
 754   }
 755   else {
 756     Standard_Integer mult  = Draw::Atoi(a[4]);
 757     if (!GBs.IsNull())
 758       GBs->SetKnot(index,knot,mult);
 759     else
 760       GBs2d->SetKnot(index,knot,mult);
 761   }
 762
 763   Draw::Repaint();
 764   return 0;
 765 }
 766
 767 //=======================================================================
 768 //function : cremknot
 769 //purpose  :
 770 //=======================================================================
 771
 772 static Standard_Integer cremknot (Draw_Interpretor& di, Standard_Integer n, const char** a)
 773 {
 774   if (n < 3) return 1;
 775
 776   Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]);
 777   Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]);
 778
 779   if (GBs.IsNull() && GBs2d.IsNull()) return 1;
 780
 781   Standard_Integer index = Draw::Atoi(a[2]);
 782   Standard_Integer mult  = 0;
 783   if (n >= 4) mult = Draw::Atoi(a[3]);
 784
 785   Standard_Real tol = RealLast();
 786   if (n >= 5) tol = Draw::Atof(a[4]);
 787
 788   if (!GBs.IsNull()) {
 789     if (!GBs->RemoveKnot(index,mult,tol))
 790       di << "Remove knots failed"<<"\n";
 791   }
 792   else {
 793     if (!GBs2d->RemoveKnot(index,mult,tol))
 794       di << "Remove knots failed"<<"\n";
 795   }
 796
 797   Draw::Repaint();
 798   return 0;
 799 }
 800
 801 //=======================================================================
 802 //function : increasedegree
 803 //purpose  :
 804 //=======================================================================
 805
 806 static Standard_Integer increasedegree (Draw_Interpretor& , Standard_Integer n, const char** a)
 807 {
 808   if (n < 3) return 1;
 809
 810   Standard_Integer Deg = Draw::Atoi(a[2]);
 811
 812   Handle(Geom_BezierCurve) GBz = DrawTrSurf::GetBezierCurve(a[1]);
 813   Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]);
 814   Handle(Geom2d_BezierCurve) GBz2d = DrawTrSurf::GetBezierCurve2d(a[1]);
 815   Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]);
 816
 817   if (!GBz.IsNull())
 818     GBz->Increase(Deg);
 819   else if (!GBs.IsNull())
 820     GBs->IncreaseDegree(Deg);
 821   else if (!GBz2d.IsNull())
 822     GBz2d->Increase(Deg);
 823   else if (!GBs2d.IsNull())
 824     GBs2d->IncreaseDegree(Deg);
 825   else
 826     return 1;
 827
 828   Draw::Repaint();
 829   return 0;
 830 }
 831
 832 //=======================================================================
 833 //function : removepole
 834 //purpose  :
 835 //=======================================================================
 836
 837 static Standard_Integer removepole (Draw_Interpretor& di, Standard_Integer n, const char** a)
 838 {
 839   if (n < 3) return 1;
 840
 841   Standard_Integer Index = Draw::Atoi(a[2]);
 842
 843   Handle(Geom_BezierCurve)   GBZ   = DrawTrSurf::GetBezierCurve(a[1]);
 844   Handle(Geom2d_BezierCurve) GBZ2d = DrawTrSurf::GetBezierCurve2d(a[1]);
 845   if (!GBZ.IsNull()) {
 846     GBZ->RemovePole(Index);
 847   }
 848   else if (!GBZ2d.IsNull()) {
 849     GBZ2d->RemovePole(Index);
 850   }
 851   else {
 852     di << "rempole needs a bezier curve";
 853     return 1;
 854   }
 855
 856   Draw::Repaint();
 857   return 0;
 858 }
 859
 860 //=======================================================================
 861 //function : insertpole
 862 //purpose  :
 863 //=======================================================================
 864
 865 static Standard_Integer insertpole (Draw_Interpretor& di, Standard_Integer n, const char** a)
 866 {
 867   if (n < 6) return 1;
 868
 869   Standard_Integer Index = Draw::Atoi(a[2]);
 870
 871   Handle(Geom_BezierCurve)   GBZ   = DrawTrSurf::GetBezierCurve(a[1]);
 872   Handle(Geom2d_BezierCurve) GBZ2d = DrawTrSurf::GetBezierCurve2d(a[1]);
 873   if (!GBZ.IsNull()) {
 874     gp_Pnt P (Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5]));
 875     if ( n == 7)
 876       GBZ->InsertPoleAfter(Index,P,Draw::Atof(a[6]));
 877     else
 878       GBZ->InsertPoleAfter(Index,P);
 879   }
 880   else if (!GBZ2d.IsNull()) {
 881     gp_Pnt2d P (Draw::Atof(a[3]),Draw::Atof(a[4]));
 882     if ( n == 6)
 883       GBZ2d->InsertPoleAfter(Index,P,Draw::Atof(a[5]));
 884     else
 885       GBZ2d->InsertPoleAfter(Index,P);
 886   }
 887   else {
 888     di << "insertpole needs a bezier curve";
 889     return 1;
 890   }
 891
 892   Draw::Repaint();
 893   return 0;
 894 }
 895
 896 //=======================================================================
 897 //function : cfindp
 898 //purpose  :
 899 //=======================================================================
 900
 901 static Standard_Integer cfindp (Draw_Interpretor& , Standard_Integer n, const char** a)
 902 {
 903   if (n < 6) return 1;
 904
 905   Standard_Integer Index = 0;
 906   Standard_Integer view = Draw::Atoi(a[2]);
 907   Standard_Real x = Draw::Atof(a[3]);
 908   Standard_Real y = Draw::Atof(a[4]);
 909
 910   Draw_Display d = dout.MakeDisplay(view);
 911
 912   Handle(Draw_Drawable3D) D = Draw::Get(a[1]);
 913
 914   Handle(DrawTrSurf_BezierCurve) DBz =
 915     Handle(DrawTrSurf_BezierCurve)::DownCast(D);
 916   if( !DBz.IsNull())
 917     DBz->FindPole( x, y, d, 5, Index);
 918   else {
 919     Handle(DrawTrSurf_BSplineCurve) DBs =
 920       Handle(DrawTrSurf_BSplineCurve)::DownCast(D);
 921     if (!DBs.IsNull())
 922       DBs->FindPole( x, y, d, 5, Index);
 923     else {
 924       Handle(DrawTrSurf_BezierCurve2d) DBz =
 925         Handle(DrawTrSurf_BezierCurve2d)::DownCast(D);
 926       if( !DBz.IsNull())
 927         DBz->FindPole( x, y, d, 5, Index);
 928       else {
 929         Handle(DrawTrSurf_BSplineCurve2d) DBs =
 930           Handle(DrawTrSurf_BSplineCurve2d)::DownCast(D);
 931         if (!DBs.IsNull())
 932           DBs->FindPole( x, y, d, 5, Index);
 933         else
 934           return 1;
 935       }
 936     }
 937   }
 938
 939   Draw::Set(a[5],Index);
 940
 941   return 0;
 942 }
 943
 944
 945 //=======================================================================
 946 //function : csetperiodic
 947 //purpose  :
 948 //=======================================================================
 949
 950 static Standard_Integer csetperiodic (Draw_Interpretor& , Standard_Integer n, const char** a)
 951 {
 952   if (n < 2) return 1;
 953
 954   Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]);
 955   Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]);
 956
 957   if (GBs.IsNull() && GBs2d.IsNull()) return 1;
 958
 959   if (!strcmp(a[0],"setperiodic")) {
 960     if (!GBs.IsNull())
 961       GBs->SetPeriodic();
 962     else
 963       GBs2d->SetPeriodic();
 964   }
 965   else if (!strcmp(a[0],"setnotperiodic")) {
 966     if (!GBs.IsNull())
 967       GBs->SetNotPeriodic();
 968     else
 969       GBs2d->SetNotPeriodic();
 970   }
 971
 972   Draw::Repaint();
 973   return 0;
 974 }
 975
 976 //=======================================================================
 977 //function : value
 978 //purpose  :
 979 //=======================================================================
 980
 981 static Standard_Integer value (Draw_Interpretor& ,
 982                                Standard_Integer n, const char** a)
 983 {
 984   if (n < 4) return 1;
 985
 986   Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[1]);
 987   if (GC.IsNull()) return 1;
 988
 989   Standard_Real U = Draw::Atof(a[2]);
 990
 991   Standard_Boolean DrawPoint = ( n%3 == 1);
 992   if ( DrawPoint) n--;
 993
 994   gp_Pnt P;
 995   if (n > 6) {
 996     if (n < 9) return 1;
 997     gp_Vec D1;
 998     if (n > 9) {
 999       if (n < 12) return 1;
1000       gp_Vec D2;
1001       GC->D2(U,P,D1,D2);
1002       Draw::Set(a[9] ,D2.X());
1003       Draw::Set(a[10],D2.Y());
1004       Draw::Set(a[11],D2.Z());
1005     }
1006     else
1007       GC->D1(U,P,D1);
1008     Draw::Set(a[6],D1.X());
1009     Draw::Set(a[7],D1.Y());
1010     Draw::Set(a[8],D1.Z());
1011   }
1012   else
1013     GC->D0(U,P);
1014
1015   if ( n > 3) {
1016     Draw::Set(a[3],P.X());
1017     Draw::Set(a[4],P.Y());
1018     Draw::Set(a[5],P.Z());
1019   }
1020   if ( DrawPoint) {
1021     DrawTrSurf::Set(a[n],P);
1022   }
1023
1024   return 0;
1025 }
1026
1027
1028 //=======================================================================
1029 //function : value2d
1030 //purpose  :
1031 //=======================================================================
1032
1033 static Standard_Integer value2d (Draw_Interpretor& ,
1034                                  Standard_Integer n, const char** a)
1035 {
1036   if (n < 4) return 1;
1037
1038   Handle(Geom2d_Curve) GC = DrawTrSurf::GetCurve2d(a[1]);
1039   if (GC.IsNull()) return 1;
1040
1041   Standard_Real U = Draw::Atof(a[2]);
1042
1043   Standard_Boolean DrawPoint = ( n%2 == 0);
1044   if ( DrawPoint ) n--;
1045
1046   gp_Pnt2d P;
1047   if (n > 5) {
1048     if (n < 7) return 1;
1049     gp_Vec2d D1;
1050     if (n > 7) {
1051       if (n < 9) return 1;
1052       gp_Vec2d D2;
1053       GC->D2(U,P,D1,D2);
1054       Draw::Set(a[7] ,D2.X());
1055       Draw::Set(a[8],D2.Y());
1056     }
1057     else
1058       GC->D1(U,P,D1);
1059     Draw::Set(a[5],D1.X());
1060     Draw::Set(a[6],D1.Y());
1061   }
1062   else
1063     GC->D0(U,P);
1064
1065   if ( n > 3 ) {
1066     Draw::Set(a[3],P.X());
1067     Draw::Set(a[4],P.Y());
1068   }
1069   if ( DrawPoint ) {
1070     DrawTrSurf::Set(a[n], P);
1071   }
1072
1073   return 0;
1074 }
1075
1076 //=======================================================================
1077 //function : segment
1078 //purpose  :
1079 //=======================================================================
1080
1081 static Standard_Integer segment (Draw_Interpretor& , Standard_Integer n, const char** a)
1082 {
1083   if (n < 4) return 1;
1084
1085   Handle(Geom_BezierCurve) GBz = DrawTrSurf::GetBezierCurve(a[1]);
1086   Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]);
1087   Handle(Geom2d_BezierCurve) GBz2d = DrawTrSurf::GetBezierCurve2d(a[1]);
1088   Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]);
1089
1090   Standard_Real f = Draw::Atof(a[2]), l = Draw::Atof(a[3]);
1091
1092   if (!GBz.IsNull())
1093     GBz->Segment(f,l);
1094   else if (!GBs.IsNull())
1095     GBs->Segment(f,l);
1096   else if (!GBz2d.IsNull())
1097     GBz2d->Segment(f,l);
1098   else if (!GBs2d.IsNull())
1099     GBs2d->Segment(f,l);
1100   else
1101     return 1;
1102
1103   Draw::Repaint();
1104   return 0;
1105 }
1106
1107
1108 //=======================================================================
1109 //function : setorigin
1110 //purpose  :
1111 //=======================================================================
1112
1113 static Standard_Integer setorigin (Draw_Interpretor& , Standard_Integer n, const char** a)
1114 {
1115   if (n < 3) return 1;
1116
1117   Handle(Geom_BSplineCurve) GBs = DrawTrSurf::GetBSplineCurve(a[1]);
1118   Handle(Geom2d_BSplineCurve) GBs2d = DrawTrSurf::GetBSplineCurve2d(a[1]);
1119
1120   if (!GBs.IsNull())
1121     GBs->SetOrigin(Draw::Atoi(a[2]));
1122   if (!GBs2d.IsNull())
1123     GBs2d->SetOrigin(Draw::Atoi(a[2]));
1124   else
1125     return 1;
1126
1127   Draw::Repaint();
1128   return 0;
1129 }
1130
1131
1132 //=======================================================================
1133 //function : point
1134 //purpose  :
1135 //=======================================================================
1136
1137 static Standard_Integer point(Draw_Interpretor& , Standard_Integer n, const char** a)
1138 {
1139   if (n < 4) return 1;
1140   if (n >= 5) {
1141     gp_Pnt P(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4]));
1142     DrawTrSurf::Set(a[1],P);
1143   }
1144   else {
1145     gp_Pnt2d P(Draw::Atof(a[2]),Draw::Atof(a[3]));
1146     DrawTrSurf::Set(a[1],P);
1147   }
1148
1149   return 0;
1150 }
1151
1152 //=======================================================================
1153 //function : coord
1154 //purpose  :
1155 //=======================================================================
1156
1157 static Standard_Integer coord(Draw_Interpretor&,
1158                               Standard_Integer n, const char** a)
1159 {
1160   if ( n == 4) {
1161     gp_Pnt2d P;
1162     if ( !DrawTrSurf::GetPoint2d(a[1],P)) return 1;
1163     Draw::Set(a[2],P.X());
1164     Draw::Set(a[3],P.Y());
1165   }
1166   else if ( n == 5) {
1167     gp_Pnt  P;
1168     if ( !DrawTrSurf::GetPoint(a[1],P)) return 1;
1169     Draw::Set(a[2],P.X());
1170     Draw::Set(a[3],P.Y());
1171     Draw::Set(a[4],P.Z());
1172   }
1173   else
1174     return 1;
1175
1176   return 0;
1177 }
1178
1179 //=======================================================================
1180 //function :
1181 //purpose  :
1182 //=======================================================================
1183 static Standard_Integer minmaxcurandinf(Draw_Interpretor& di,
1184                                    Standard_Integer argc, const char** argv)
1185 {
1186   if (argc < 2) return 1;
1187
1188   Handle(Geom2d_Curve)  C1 = DrawTrSurf::GetCurve2d(argv[1]);
1189   if (C1.IsNull()) return 1;
1190
1191   Draw_Color              Couleur;
1192   Geom2dLProp_CurAndInf2d Sommets;
1193
1194   Sommets.PerformCurExt (C1);
1195   if (Sommets.IsDone() && !Sommets.IsEmpty()) {
1196     for (Standard_Integer i = 1; i <= Sommets.NbPoints(); i++){
1197       Couleur = Draw_vert;
1198       if (Sommets.Type(i) == LProp_MinCur) {
1199         Couleur = Draw_orange;
1200         di << "  Maximum of curvature at U ="<<Sommets.Parameter(i)<<"\n";
1201       }
1202       else {
1203         di << "  Minimum of curvature at U ="<<Sommets.Parameter(i)<<"\n";
1204       }
1205       gp_Pnt2d P = C1->Value(Sommets.Parameter(i));
1206       Handle(Draw_Marker2D) dr = new Draw_Marker2D(P,Draw_Plus,Couleur);
1207       dout << dr;
1208     }
1209     dout.Flush();
1210   }
1211
1212   Geom2dLProp_CurAndInf2d Sommets2;
1213   Sommets2.PerformInf (C1);
1214
1215   if (Sommets2.IsDone() && !Sommets2.IsEmpty()) {
1216     for (Standard_Integer i = 1; i <= Sommets2.NbPoints(); i++){
1217       gp_Pnt2d P = C1->Value(Sommets2.Parameter(i));
1218       Handle(Draw_Marker2D) dr = new Draw_Marker2D(P,Draw_Plus,Draw_bleu);
1219       dout << dr;
1220       di << "  Inflexion at U ="<<Sommets2.Parameter(i)<<"\n";
1221     }
1222     dout.Flush();
1223   }
1224   return 0;
1225 }
1226 //=======================================================================
1227 //function :  shcurvature
1228 //purpose  :  affiche le peigne de courbure
1229 //=======================================================================
1230 static Standard_Integer shcurvature(Draw_Interpretor&,
1231                                    Standard_Integer argc, const char** argv)
1232 {
1233   if (argc < 2) return 1;
1234
1235    Handle(DrawTrSurf_Curve2d) C2d =  Handle(DrawTrSurf_Curve2d)
1236                                   ::DownCast(Draw::Get(argv[1]));
1237    Handle(DrawTrSurf_Curve) C3d =  Handle(DrawTrSurf_Curve)
1238                                   ::DownCast(Draw::Get(argv[1]));
1239
1240   if (C2d.IsNull()) {
1241     if (C3d.IsNull()) return 1;
1242     C3d->ShowCurvature();
1243   }
1244   else {
1245     C2d->ShowCurvature();
1246   }
1247   Draw::Repaint();
1248   return 0;
1249 }
1250
1251 //=======================================================================
1252 //function :  clcurvature
1253 //purpose  :  efface le peigne de courbure
1254 //=======================================================================
1255 static Standard_Integer clcurvature(Draw_Interpretor&,
1256                                    Standard_Integer argc, const char** argv)
1257 {
1258   if (argc < 2) return 1;
1259    Handle(DrawTrSurf_Curve2d) C2d =  Handle(DrawTrSurf_Curve2d)
1260                                   ::DownCast(Draw::Get(argv[1]));
1261    Handle(DrawTrSurf_Curve) C3d =  Handle(DrawTrSurf_Curve)
1262                                   ::DownCast(Draw::Get(argv[1]));
1263
1264   if (C2d.IsNull()) {
1265     if (C3d.IsNull()) return 1;
1266     C3d->ClearCurvature();
1267   }
1268   else {
1269     C2d->ClearCurvature();
1270   }
1271   Draw::Repaint();
1272   return 0;
1273 }
1274
1275 //=======================================================================
1276 //function :  radiusmax
1277 //purpose  :  definit le rayon de courbure maximum a afficher
1278 //=======================================================================
1279 static Standard_Integer radiusmax(Draw_Interpretor&,
1280                                   Standard_Integer argc, const char** argv)
1281 {
1282   if (argc < 3) return 1;
1283   Standard_Real Radius = Draw::Atof(argv[2]);
1284    Handle(DrawTrSurf_Curve2d) C2d =  Handle(DrawTrSurf_Curve2d)
1285                                   ::DownCast(Draw::Get(argv[1]));
1286    Handle(DrawTrSurf_Curve) C3d =  Handle(DrawTrSurf_Curve)
1287                                   ::DownCast(Draw::Get(argv[1]));
1288
1289   if (C2d.IsNull()) {
1290     if (C3d.IsNull()) return 1;
1291     C3d->SetRadiusMax(Radius);
1292   }
1293   else {
1294     C2d->SetRadiusMax(Radius);
1295   }
1296   Draw::Repaint();
1297   return 0;
1298 }
1299
1300 //=======================================================================
1301 //function :  radiusratio
1302 //purpose  :  definit le ratio du rayon de courbure a afficher
1303 //=======================================================================
1304 static Standard_Integer radiusratio(Draw_Interpretor&,
1305                                   Standard_Integer argc, const char** argv)
1306 {
1307   if (argc < 3) return 1;
1308   Standard_Real Ratio = Draw::Atof(argv[2]);
1309   Handle(DrawTrSurf_Curve2d) C2d =  Handle(DrawTrSurf_Curve2d)
1310                                   ::DownCast(Draw::Get(argv[1]));
1311   Handle(DrawTrSurf_Curve) C3d =  Handle(DrawTrSurf_Curve)
1312                                   ::DownCast(Draw::Get(argv[1]));
1313
1314   if (C2d.IsNull()) {
1315     if (C3d.IsNull()) return 1;
1316     C3d->SetRadiusRatio(Ratio);
1317   }
1318   else {
1319     C2d->SetRadiusRatio(Ratio);
1320   }
1321   Draw::Repaint();
1322   return 0;
1323 }
1324
1325 //=======================================================================
1326 //function :
1327 //purpose  :
1328 //=======================================================================
1329 static Standard_Integer localprop(Draw_Interpretor& di,
1330                                   Standard_Integer argc, const char** argv)
1331 {
1332   if (argc < 3) return 1;
1333
1334   Standard_Real U =  Draw::Atof(argv[2]);
1335
1336   Handle(Geom2d_Curve)  C2d = DrawTrSurf::GetCurve2d(argv[1]);
1337   Handle(Geom_Curve)    C3d;
1338
1339
1340   if (C2d.IsNull()) {
1341     C3d = DrawTrSurf::GetCurve(argv[1]);
1342     if (C3d.IsNull()) return 1;
1343     GeomLProp_CLProps Prop (C3d,2,Precision::Confusion());
1344     Prop.SetParameter(U);
1345     Handle(Draw_Marker3D)drp = new Draw_Marker3D(Prop.Value(),
1346                                                  Draw_Plus,
1347                                                  Draw_vert );
1348     dout << drp;
1349     if (Prop.IsTangentDefined()) {
1350       Standard_Real K = Prop.Curvature();
1351       di <<" Curvature : "<<K<<"\n";
1352
1353       if (Abs(K) > Precision::Confusion()) {
1354         Standard_Real R = 1/Abs(K);
1355         gp_Pnt        Center;
1356         Prop.CentreOfCurvature(Center);
1357         gp_Dir Tang;
1358         gp_Dir Nor;
1359         Prop.Tangent(Tang);
1360         Prop.Normal(Nor);
1361         gp_Dir AxC = Nor^Tang;
1362         gp_Ax2 Axe(Center,AxC,Nor);
1363         Handle(Geom_Circle) Cir3d = new Geom_Circle(Axe,R);
1364         Handle(DrawTrSurf_Curve) dr;
1365         dr = new DrawTrSurf_Curve(Cir3d);
1366         dout << dr;
1367         dout.Flush();
1368       }
1369     }
1370     else
1371       di <<"Tangent undefined."<<"\n";
1372   }
1373   else {
1374     Geom2dLProp_CLProps2d Prop (C2d,2,Precision::Confusion());
1375     Prop.SetParameter(U);
1376     Handle(Draw_Marker2D) drp = new Draw_Marker2D(Prop.Value(),
1377                                                   Draw_Plus,
1378                                                   Draw_vert);
1379     dout << drp;
1380     if (Prop.IsTangentDefined()) {
1381       Standard_Real K = Prop.Curvature();
1382       gp_Pnt2d      Center;
1383
1384       di <<" Curvature : "<<K<<"\n";
1385
1386       if (Abs(K) > Precision::Confusion()) {
1387         Standard_Real R = 1/Abs(K);
1388         Prop.CentreOfCurvature(Center);
1389         gp_Ax2d Axe(Center,gp::DX2d());
1390         Handle(Geom2d_Circle) Cir2d = new Geom2d_Circle(Axe,R);
1391         Handle(DrawTrSurf_Curve2d) dr;
1392         dr = new DrawTrSurf_Curve2d(Cir2d,Draw_rouge,30,Standard_False);
1393         dout << dr;
1394         dout.Flush();
1395       }
1396     }
1397     else
1398       di <<"Tangent undefined."<<"\n";
1399   }
1400   return 0;
1401 }
1402 //=======================================================================
1403 //function : rawcont
1404 //purpose  :
1405 //=======================================================================
1406
1407 static Standard_Integer rawcont(Draw_Interpretor& di, Standard_Integer n, const char** a)
1408 {
1409   if (n < 5) return 1;
1410
1411   Handle(Geom_Curve) GC1;
1412   GC1 = DrawTrSurf::GetCurve(a[1]);
1413   Handle(Geom_Curve) GC2;
1414   GC2 = DrawTrSurf::GetCurve(a[2]);
1415   Standard_Real param1 =
1416     Draw::Atof(a[3]) ;
1417   Standard_Real param2 =
1418     Draw::Atof(a[4]) ;
1419   if (GC1.IsNull() || GC2.IsNull())
1420     return 1;
1421   gp_Pnt a_point1,
1422     a_point2 ;
1423   GC1->D0(param1,
1424           a_point1) ;
1425   GC2->D0(param2,
1426           a_point2) ;
1427   if (a_point2.SquareDistance(a_point1) < Precision::Confusion()) {
1428     GeomAbs_Shape cont =
1429       GeomLProp::Continuity(GC1,
1430                             GC2,
1431                             param1,
1432                             param2,
1433                             Standard_True,
1434                             Standard_True,
1435                             Precision::Confusion(),
1436                             Precision::Angular()) ;
1437     switch (cont) {
1438     case GeomAbs_C0:
1439       di << " C0 Continuity " << "\n" ;
1440       break ;
1441     case GeomAbs_G1:
1442       di << " G1 Continuity " << "\n" ;
1443       break ;
1444     case GeomAbs_C1 :
1445       di << " C1 Continuity " << "\n" ;
1446       break ;
1447     case GeomAbs_G2 :
1448       di << " G2 Continuity " << "\n" ;
1449       break ;
1450     case GeomAbs_C2 :
1451       di << " C2 Continuity " << "\n" ;
1452       break ;
1453     case GeomAbs_C3 :
1454       di << " C3 Continuity " << "\n" ;
1455       break ;
1456     case GeomAbs_CN :
1457       di << " CN Continuity " << "\n" ;
1458       break ;
1459     default:
1460       break ;
1461     }
1462   }
1463   else {
1464     di << " not C0 continuity " << "\n" ;
1465   }
1466   return 0 ;
1467 }
1468 //=======================================================================
1469 //function : approxcurveonsurf
1470 //purpose  :
1471 //=======================================================================
1472 static Standard_Integer approxcurveonsurf(Draw_Interpretor& di, Standard_Integer n, const char** a)
1473 {
1474   Standard_Real Tol = 1.e-7;              // Tolerance (default 0.1mm)
1475   GeomAbs_Shape Continuity = GeomAbs_C1;  // Continuity order : 0, 1 or 2 (default 1)
1476   Standard_Integer MaxDeg = 14;           // Maximum degree
1477   Standard_Integer MaxSeg = 16; /*1*/          // Maximum number of segments
1478
1479   if ( n>8 || n<4) return 1;
1480
1481   if (n>4) Tol = Max(Draw::Atof(a[4]),1.e-10);
1482
1483   if (n>5) {
1484     if (Draw::Atoi(a[5]) == 0) Continuity = GeomAbs_C0;
1485     if (Draw::Atoi(a[5]) == 2) Continuity = GeomAbs_C2;
1486   }
1487
1488   if (n>6) {
1489     MaxDeg = Draw::Atoi(a[6]);
1490     if (MaxDeg<1 || MaxDeg>14) MaxDeg = 14;
1491   }
1492
1493   if (n>7) MaxSeg = Draw::Atoi(a[7]);
1494   Handle(Geom2d_Curve) curve2d = DrawTrSurf::GetCurve2d(a[2]);
1495   Handle(Geom_Surface) Surf = DrawTrSurf::GetSurface(a[3]);
1496
1497   Handle(Geom2dAdaptor_HCurve) A2d = new (Geom2dAdaptor_HCurve)(curve2d);
1498   Handle(GeomAdaptor_HSurface) AS = new (GeomAdaptor_HSurface)(Surf);
1499
1500   Approx_CurveOnSurface App(A2d, AS, A2d->FirstParameter(), A2d->LastParameter(),
1501                             Tol,  Continuity,  MaxDeg, MaxSeg,
1502                             Standard_True, Standard_False);
1503
1504   if(App.HasResult()) {
1505     Handle(Geom_BSplineCurve) BSCurve = App.Curve3d();
1506     DrawTrSurf::Set(a[1], BSCurve);
1507     return 0;
1508   }
1509
1510   di << "Approximation failed !" << "\n";
1511   return 1;
1512
1513 }
1514
1515 //=======================================================================
1516 //function : approxcurve
1517 //purpose  :
1518 //=======================================================================
1519 static Standard_Integer approxcurve(Draw_Interpretor& di, Standard_Integer n, const char** a)
1520 {
1521   Standard_Real Tol = 1.e-7;              // Tolerance (default 0.1mm)
1522   GeomAbs_Shape Continuity = GeomAbs_C1;  // Continuity order : 0, 1 or 2 (default 1)
1523   Standard_Integer MaxDeg = 14;           // Maximum degree
1524   Standard_Integer MaxSeg = 16;           // Maximum number of segments
1525
1526   Standard_Integer Case, shift;
1527 // Case == 1 : 3d approximation without reparametrization
1528 // Case == 2 : 2d approximation without reparametrization
1529 // Case == 3 : 3d approximation with reparametrization
1530 // Case == 4 : curve_on_surface approximation with reparametrization
1531 // Case == 5 : 2 curves_on_surfaces approximation with reparametrization
1532
1533   Handle(Geom_Curve) curve;
1534   Handle(Geom2d_Curve) curve2d, curve2d2;
1535   Handle(Geom_Surface) surface, surface2;
1536
1537   if(n < 2) return 1;
1538
1539   if (!strcmp(a[1],"-L")) {
1540 // aproximation with curvilinear abscissa reparametrization
1541     if (n > 11 || n < 4) return 1;
1542     Tol = 1.e-4;
1543     curve = DrawTrSurf::GetCurve(a[3]);
1544     if (!curve.IsNull()) {
1545       shift = 4;
1546       Case = 3;
1547     }
1548     else {
1549 // approx curve_on_surface
1550       if (n < 5) return 1;
1551       curve2d = DrawTrSurf::GetCurve2d(a[3]);
1552       surface = DrawTrSurf::GetSurface(a[4]);
1553       if (curve2d.IsNull() || surface.IsNull()) {
1554         return 1;
1555       }
1556       if (n >= 7) {
1557         curve2d2 = DrawTrSurf::GetCurve2d(a[5]);
1558         surface2 = DrawTrSurf::GetSurface(a[6]);
1559         if (curve2d2.IsNull() || surface2.IsNull()) {
1560           shift = 5;
1561           Case = 4;
1562         }
1563         else {
1564 // approx 2 curves_on_surfaces
1565           shift = 7;
1566           Case = 5;
1567         }
1568       }
1569       else {
1570         shift = 5;
1571         Case = 4;
1572       }
1573     }
1574   }
1575   else {
1576 // aproximation without reparamitrization
1577     if ( n>7 || n<3) return 1;
1578     shift = 3;
1579     curve = DrawTrSurf::GetCurve(a[2]);
1580     if (curve.IsNull()) {
1581       curve2d = DrawTrSurf::GetCurve2d(a[2]);
1582       if (curve2d.IsNull()) {
1583         return 1;
1584       }
1585       Case = 2;
1586     }
1587     else
1588       Case = 1;
1589   }
1590
1591   if (n>shift) Tol = Max(Draw::Atof(a[shift]),1.e-10);
1592
1593   if (n>shift+1) {
1594     if (Draw::Atoi(a[shift+1]) == 0) Continuity = GeomAbs_C0;
1595     if (Draw::Atoi(a[shift+1]) == 2) Continuity = GeomAbs_C2;
1596   }
1597
1598   if (n>shift+2) {
1599       MaxDeg = Draw::Atoi(a[shift+2]);
1600       if (MaxDeg<1 || MaxDeg>14) MaxDeg = 14;
1601     }
1602
1603   if (n>shift+3) MaxSeg = Draw::Atoi(a[shift+3]);
1604
1605   if (Case == 1) {
1606     GeomConvert_ApproxCurve appr(curve, Tol, Continuity, MaxSeg, MaxDeg);
1607     if(appr.HasResult()) {
1608       //appr.Dump(cout);
1609       Standard_SStream aSStream;
1610       appr.Dump(aSStream);
1611       di << aSStream;
1612       Handle(Geom_BSplineCurve) BSCurve = appr.Curve();
1613       DrawTrSurf::Set(a[1], BSCurve);
1614     }
1615  }
1616
1617   else if (Case == 2) {
1618     Geom2dConvert_ApproxCurve appr(curve2d, Tol, Continuity, MaxSeg, MaxDeg);
1619     if(appr.HasResult()) {
1620       //appr.Dump(cout);
1621       Standard_SStream aSStream;
1622       appr.Dump(aSStream);
1623       di << aSStream;
1624       Handle(Geom2d_BSplineCurve) BSCurve = appr.Curve();
1625       DrawTrSurf::Set(a[1], BSCurve);
1626     }
1627   }
1628
1629   else if (Case == 3) {
1630     Handle(Adaptor3d_HCurve) HACur = new GeomAdaptor_HCurve(curve);
1631     Approx_CurvilinearParameter appr(HACur, Tol, Continuity, MaxDeg, MaxSeg);
1632     if(appr.HasResult()) {
1633       //appr.Dump(cout);
1634       Standard_SStream aSStream;
1635       appr.Dump(aSStream);
1636       di << aSStream;
1637       Handle(Geom_BSplineCurve) BSCurve = appr.Curve3d();
1638       DrawTrSurf::Set(a[2], BSCurve);
1639     }
1640 }
1641   else if (Case == 4) {
1642     Handle(Adaptor2d_HCurve2d) HACur2d = new Geom2dAdaptor_HCurve(curve2d);
1643     Handle(Adaptor3d_HSurface) HASur = new GeomAdaptor_HSurface(surface);
1644     Approx_CurvilinearParameter appr(HACur2d, HASur, Tol, Continuity, MaxDeg, MaxSeg);
1645     if(appr.HasResult()) {
1646       //appr.Dump(cout);
1647       Standard_SStream aSStream;
1648       appr.Dump(aSStream);
1649       di << aSStream;
1650       Handle(Geom_BSplineCurve) BSCurve = appr.Curve3d();
1651       DrawTrSurf::Set(a[2], BSCurve);
1652     }
1653   }
1654
1655   else if (Case == 5) {
1656     Handle(Adaptor2d_HCurve2d) HACur2d = new Geom2dAdaptor_HCurve(curve2d);
1657     Handle(Adaptor3d_HSurface) HASur = new GeomAdaptor_HSurface(surface);
1658     Handle(Adaptor2d_HCurve2d) HACur2d2 = new Geom2dAdaptor_HCurve(curve2d2);
1659     Handle(Adaptor3d_HSurface) HASur2 = new GeomAdaptor_HSurface(surface2);
1660     Approx_CurvilinearParameter appr(HACur2d, HASur, HACur2d2, HASur2, Tol, Continuity, MaxDeg, MaxSeg);
1661     if(appr.HasResult()) {
1662       //appr.Dump(cout);
1663       Standard_SStream aSStream;
1664       appr.Dump(aSStream);
1665       di << aSStream;
1666       Handle(Geom_BSplineCurve) BSCurve = appr.Curve3d();
1667       DrawTrSurf::Set(a[2], BSCurve);
1668     }
1669   }
1670
1671
1672   return 0;
1673 }
1674
1675 //=======================================================================
1676 //function : newbspline
1677 //purpose  : reduce the multiplicity of the knots to their minimum
1678 //           compared to the degree of the curve
1679 //=======================================================================
1680
1681 static Standard_Integer splitc1(Draw_Interpretor& di,
1682                                    Standard_Integer n, const char** c)
1683
1684 {Standard_Real      tolerance=1.0e-5,
1685    angular_tolerance = 1.0e-4 ;
1686  Standard_Integer   optiontab,i;
1687  char name[100];
1688
1689  if (n<3) return 1;
1690  optiontab=Draw::Atoi(c[2]);
1691  if (n >= 4 )
1692    tolerance=Draw::Atof(c[3]);
1693  if (n >= 5) {
1694    angular_tolerance = Draw::Atof(c[4]) ;
1695  }
1696  Handle(Geom_Curve) ACurve = Handle(Geom_Curve)::DownCast(DrawTrSurf::Get(c[1])) ;
1697
1698  Standard_Real f = ACurve->FirstParameter();
1699  Standard_Real l = ACurve->LastParameter();
1700
1701  if ( Precision::IsInfinite(f) || Precision::IsInfinite(l)) {
1702    di << " Error: Infinite curves" << "\n";
1703    return 1;
1704  }
1705
1706  Handle(Geom_BSplineCurve) BS = GeomConvert::CurveToBSplineCurve(ACurve);
1707
1708  if ( BS.IsNull()) return 1;
1709
1710  if (optiontab){
1711    Handle(TColGeom_HArray1OfBSplineCurve)  tabBS;
1712    GeomConvert::C0BSplineToArrayOfC1BSplineCurve(BS,
1713                                                  tabBS,
1714                                                  angular_tolerance,
1715                                                  tolerance);
1716    for (i=0;i<=(tabBS->Length()-1);i++){
1717      Sprintf(name,"%s_%d",c[1],i+1);
1718      Standard_CString new_name = name ;
1719      DrawTrSurf::Set(new_name,
1720                      tabBS->Value(i));
1721      di.AppendElement(name);
1722    }
1723  }
1724  else{
1725    GeomConvert::C0BSplineToC1BSplineCurve(BS,
1726                                           tolerance,
1727                                           angular_tolerance) ;
1728
1729    DrawTrSurf::Set(c[1],BS);
1730  }
1731  return 0;
1732 }
1733
1734 //=======================================================================
1735 //function : splitc12d
1736 //purpose  : reduce the multiplicity of the knots to their minimum
1737 //           compared to the degree of the curve
1738 //=======================================================================
1739
1740 static Standard_Integer splitc12d(Draw_Interpretor& di,
1741                                      Standard_Integer n, const char** c)
1742
1743 {Standard_Real      tolerance=1.0e-5,
1744    angular_tolerance = 1.0e-4 ;
1745  Standard_Integer   optiontab,i;
1746  char name[100];
1747
1748  if (n<3) return 1;
1749  optiontab=Draw::Atoi(c[2]);
1750  if (n==4)
1751    tolerance=Draw::Atof(c[3]);
1752  if (n==5)
1753    angular_tolerance = Draw::Atof(c[4]) ;
1754  Handle(Geom2d_Curve) ACurve = Handle(Geom2d_Curve)::DownCast(DrawTrSurf::GetCurve2d(c[1])) ;
1755
1756  Standard_Real f = ACurve->FirstParameter();
1757  Standard_Real l = ACurve->LastParameter();
1758
1759  if ( Precision::IsInfinite(f) || Precision::IsInfinite(l)) {
1760    di << " Error: Infinite curves" << "\n";
1761    return 1;
1762  }
1763
1764  Handle(Geom2d_BSplineCurve) BS = Geom2dConvert::CurveToBSplineCurve(ACurve);
1765
1766  if ( BS.IsNull()) return 1;
1767
1768  if (optiontab){
1769    Handle(TColGeom2d_HArray1OfBSplineCurve)  tabBS;
1770    Geom2dConvert::C0BSplineToArrayOfC1BSplineCurve(BS,
1771                                                    tabBS,
1772                                                    angular_tolerance,
1773                                                    tolerance);
1774    for (i=0;i<=(tabBS->Length()-1);i++){
1775      Sprintf(name,"%s_%d",c[1],i+1);
1776      Standard_CString new_name = name ;
1777      DrawTrSurf::Set(new_name,
1778                      tabBS->Value(i));
1779      di.AppendElement(name);
1780    }
1781  }
1782  else{
1783    Geom2dConvert::C0BSplineToC1BSplineCurve(BS,tolerance);
1784    DrawTrSurf::Set(c[1],BS);
1785  }
1786  return 0;
1787 }
1788
1789 //=======================================================================
1790 //function : canceldenom
1791 //purpose  : set the value of the denominator cancel its first
1792 //           derivative on the boundaries of the surface if possible
1793 //=======================================================================
1794
1795 static Standard_Integer canceldenom(Draw_Interpretor& ,
1796                                      Standard_Integer n, const char** c)
1797
1798 {Standard_Integer    uoption,voption;
1799  Standard_Boolean    udirection=Standard_False;
1800  Standard_Boolean    vdirection=Standard_False;
1801  if (n<4) return 1;
1802  uoption=Draw::Atoi(c[2]);
1803  voption=Draw::Atoi(c[3]);
1804  if (uoption)
1805    udirection=Standard_True;
1806  if (voption)
1807    vdirection=Standard_True;
1808  Handle(Geom_BSplineSurface) BSurf = Handle(Geom_BSplineSurface)::DownCast(DrawTrSurf::GetBSplineSurface(c[1]));
1809  GeomLib::CancelDenominatorDerivative(BSurf,udirection,vdirection);
1810  DrawTrSurf::Set(c[1],BSurf);
1811  return 0;
1812 }
1813
1814 //=======================================================================
1815 //function : length
1816 //purpose  : eval curve's length
1817 //=======================================================================
1818
1819 static Standard_Integer length(Draw_Interpretor& di,
1820                                Standard_Integer n, const char** a)
1821 {
1822   if (n<2) return 1;
1823   Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[1]);
1824   Handle(Geom2d_Curve) GC2d = DrawTrSurf::GetCurve2d(a[1]);
1825   Standard_Real Tol = Precision::Confusion(), L;
1826   if (n==3) Tol = Draw::Atof(a[2]);
1827
1828   if (!GC.IsNull()) {
1829     GeomAdaptor_Curve AC(GC);
1830     L = GCPnts_AbscissaPoint::Length(AC, Tol);
1831   }
1832   else if (!GC2d.IsNull()) {
1833     Geom2dAdaptor_Curve AC(GC2d);
1834     L = GCPnts_AbscissaPoint::Length(AC, Tol);
1835   }
1836   else {
1837     di << a[1] << "is not a curve" << "\n";
1838     return 1;
1839   }
1840
1841   di << "The length " << a[1] << " is " << L << "\n";
1842   return 0;
1843 }
1844
1845
1846
1847 //=======================================================================
1848 //function : CurveCommands
1849 //purpose  :
1850 //=======================================================================
1851
1852 void  GeomliteTest::CurveCommands(Draw_Interpretor& theCommands)
1853 {
1854
1855   static Standard_Boolean loaded = Standard_False;
1856   if (loaded) return;
1857   loaded = Standard_True;
1858
1859   DrawTrSurf::BasicCommands(theCommands);
1860
1861   const char* g;
1862
1863
1864   // analytic curves
1865   g = "GEOMETRY curves creation";
1866
1867
1868   theCommands.Add("point",
1869                   "point name x y [z]",
1870                   __FILE__,
1871                   point ,g);
1872
1873   theCommands.Add("line",
1874                   "line name pos dir",
1875                   __FILE__,
1876                   anacurve,g);
1877
1878   theCommands.Add("circle",
1879                   "circle name x y [z [dx dy dz]] [ux uy [uz]] radius",
1880                   __FILE__,
1881                   anacurve,g);
1882
1883   theCommands.Add("ellipse",
1884                   "ellipse name x y [z [dx dy dz]] [ux uy [uz]] major minor",
1885                   __FILE__,
1886                   anacurve,g);
1887   theCommands.Add("parabola",
1888                   "parabola name x y [z [dx dy dz]] [ux uy [uz]] focal",
1889                   __FILE__,
1890                   anacurve,g);
1891   theCommands.Add("hyperbola",
1892                   "hyperbola name x y [z [dx dy dz]] [ux uy [uz]] major minor",
1893                   __FILE__,
1894                   anacurve,g);
1895
1896   theCommands.Add("beziercurve",
1897                   "beziercurve name nbpole pole, [weight]",
1898                   __FILE__,
1899                   polecurve,g);
1900
1901   theCommands.Add("bsplinecurve",
1902                   "bsplinecurve name degree nbknots  knot, umult  pole, weight",
1903                   __FILE__,
1904                   polecurve,g);
1905
1906   theCommands.Add("pbsplinecurve",
1907                   "pbsplinecurve name degree nbknots  knot, umult  pole, weight (periodic)",
1908                   __FILE__,
1909                   polecurve,g);
1910
1911   theCommands.Add("2dbeziercurve",
1912                   "2dbeziercurve name nbpole pole, [weight]",
1913                   __FILE__,
1914                   polecurve2d,g);
1915
1916   theCommands.Add("2dbsplinecurve",
1917                   "2dbsplinecurve name degree nbknots  knot, umult  pole, weight",
1918                   __FILE__,
1919                   polecurve2d,g);
1920
1921   theCommands.Add("2dpbsplinecurve",
1922                   "2dpbsplinecurve name degree nbknots  knot, umult  pole, weight (periodic)",
1923                   __FILE__,
1924                   polecurve2d,g);
1925
1926   g = "GEOMETRY Curves and Surfaces modification";
1927
1928   theCommands.Add("reverse",
1929                   "reverse name ... ",
1930                   __FILE__,
1931                   reverse,g);
1932
1933   theCommands.Add("cmovep",
1934                   "cmovep name index dx dy dz",
1935                   __FILE__,
1936                   cmovepole,g);
1937
1938   theCommands.Add("cmovepoint",
1939                   "cmovepoint name u dx dy [dz index1 index2]",
1940                   __FILE__,
1941                   cmovepoint,g);
1942
1943   theCommands.Add("cmovetangent",
1944                   "cmovetangent name u  x y [z] tx ty [tz constraint = 0]",
1945                   __FILE__,
1946                   cmovetangent,g) ;
1947
1948   theCommands.Add("insertknot",
1949                   "insertknot name knot [mult = 1] [knot mult ...]",
1950                   __FILE__,
1951                   cinsertknot,g);
1952
1953   theCommands.Add("setknot",
1954                   "setknot name index knot [mult]",
1955                   __FILE__,
1956                   csetknot,g);
1957
1958   theCommands.Add("remknot",
1959                   "remknot name index [mult] [tol]",
1960                   __FILE__,
1961                   cremknot,g);
1962
1963   theCommands.Add("incdeg",
1964                   "incdeg name degree",
1965                   __FILE__,
1966                   increasedegree,g);
1967
1968   theCommands.Add("rempole",
1969                   "rempole name index",
1970                   __FILE__,
1971                   removepole,g);
1972
1973   theCommands.Add("insertpole",
1974                   "insertpole name index x y [z] [weight]",
1975                   __FILE__,
1976                   insertpole,g);
1977
1978   theCommands.Add("cfindp",
1979                   "cfindp name view x y index",
1980                   __FILE__,
1981                   cfindp,g);
1982
1983   theCommands.Add("setperiodic",
1984                   "setperiodic name ...",
1985                   __FILE__,
1986                   csetperiodic,g);
1987
1988   theCommands.Add("setnotperiodic",
1989                   "setnotperiodic name",
1990                   __FILE__,
1991                   csetperiodic,g);
1992
1993   theCommands.Add("segment",
1994                   "segment name Ufirst Ulast",
1995                    __FILE__,
1996                   segment , g);
1997
1998   theCommands.Add("setorigin",
1999                   "setorigin name knotindex",
2000                    __FILE__,
2001                   setorigin , g);
2002
2003   g = "GEOMETRY curves and surfaces analysis";
2004
2005   theCommands.Add("cvalue",
2006                   "cvalue curvename U  X Y Z [D1X D1Y D1Z D2X D2Y D2Z]",
2007                   __FILE__,
2008                   value,g);
2009
2010   theCommands.Add("2dcvalue",
2011                   "2dcvalue curvename U  X Y [D1X D1Y D2X D2Y]",
2012                   __FILE__,
2013                   value2d,g);
2014
2015   theCommands.Add("coord",
2016                   "coord P x y [z]: set in x y [z] the coordinates of P",
2017                   __FILE__,
2018                   coord,g);
2019
2020   theCommands.Add("minmaxcurandinf",
2021                   "minmaxcurandinf curve",
2022                   __FILE__,
2023                   minmaxcurandinf,g);
2024
2025   theCommands.Add("shcurvature",
2026                   "shcurvature curvename",
2027                   __FILE__,
2028                   shcurvature,g);
2029
2030   theCommands.Add("clcurvature",
2031                   "clcurvature curvename",
2032                   __FILE__,
2033                   clcurvature,g);
2034
2035
2036  theCommands.Add("radiusmax",
2037                   "radiusmax curvename  radius",
2038                   __FILE__,
2039                   radiusmax,g);
2040
2041  theCommands.Add("radiusratio",
2042                   "radiusratio curvename ratio",
2043                   __FILE__,
2044                   radiusratio,g);
2045   theCommands.Add("localprop",
2046                   "localprop curvename U",
2047                   __FILE__,
2048                   localprop,g);
2049   theCommands.Add("rawcont",
2050                   "rawcont curve1 curve2 u1 u2",
2051                   __FILE__,
2052                   rawcont,g) ;
2053   theCommands.Add("approxcurve",
2054                   "approxcurve [-L] name curve1 [Surf1] [curve2d2 Surf2] [Tol [cont [maxdeg [maxseg]]]] ",
2055                   __FILE__,
2056                   approxcurve,g);
2057
2058   theCommands.Add("approxcurveonsurf",
2059                   "approxcurveonsurf name curve2d surface [Tol [cont [maxdeg [maxseg]]]] ",
2060                   __FILE__,
2061                   approxcurveonsurf,g);
2062
2063  theCommands.Add("length", "length curve [Tol]",
2064                   __FILE__,
2065                   length, g);
2066
2067
2068   theCommands.Add("splitc1",
2069                   "splitc1 bspline resultinarray(0/1) [tol] [angtol] ",
2070                   __FILE__,
2071                   splitc1,g);
2072
2073   theCommands.Add("splitc12d",
2074                   "splitc12d bspline2d resultinarray(0/1) [tol] [angtol] ",
2075                   __FILE__,
2076                   splitc12d,g);
2077   theCommands.Add("canceldenom",
2078                   "canceldenom BSpline-Surface UDirection(0/1) VDirection(0/1)",
2079                   __FILE__,
2080                   canceldenom,g);
2081
2082
2083
2084 }