0027104: DownCast() cannot return null for mismatched handle
[occt.git] / 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 _WIN32
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) DBz2d = 
925         Handle(DrawTrSurf_BezierCurve2d)::DownCast(D);
926       if( !DBz2d.IsNull())
927         DBz2d->FindPole( x, y, d, 5, Index);
928       else {
929         Handle(DrawTrSurf_BSplineCurve2d) DBs2d = 
930           Handle(DrawTrSurf_BSplineCurve2d)::DownCast(D);
931         if (!DBs2d.IsNull())
932           DBs2d->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 = 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 = 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 }