199e044083690faadf32b3b30c3fd50457d7c5f1
[occt.git] / src / GeomliteTest / GeomliteTest_SurfaceCommands.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 #ifdef HAVE_CONFIG_H
18 # include <config.h>
19 #endif
20 #include <GeomliteTest.hxx>
21 #include <DrawTrSurf.hxx>
22 #include <Draw.hxx>
23 #include <Draw_Interpretor.hxx>
24 #include <Draw_Appli.hxx>
25 #include <Draw_Display.hxx>
26
27 #include <GeomAbs_SurfaceType.hxx>
28 #include <GeomAbs_IsoType.hxx>
29 #include <GeomAbs_Shape.hxx>
30
31 #include <Geom_Plane.hxx>
32 #include <Geom_CylindricalSurface.hxx>
33 #include <Geom_ConicalSurface.hxx>
34 #include <Geom_SphericalSurface.hxx>
35 #include <Geom_ToroidalSurface.hxx>
36 #include <Geom_BezierSurface.hxx>
37 #include <Geom_BSplineSurface.hxx>
38 #include <Geom_SurfaceOfLinearExtrusion.hxx>
39 #include <Geom_SurfaceOfRevolution.hxx>
40 #include <Geom_RectangularTrimmedSurface.hxx>
41 #include <Geom_OffsetSurface.hxx>
42 #include <Geom_Surface.hxx>
43
44 #include <Geom_TrimmedCurve.hxx>
45 #include <Geom_OffsetCurve.hxx>
46 #include <Geom_BezierCurve.hxx>
47 #include <Geom_BSplineCurve.hxx>
48
49 #include <Geom2d_TrimmedCurve.hxx>
50 #include <Geom2d_OffsetCurve.hxx>
51
52 #include <GeomAdaptor_Surface.hxx>
53 #include <GeomAdaptor_HSurface.hxx>
54 #include <GeomAdaptor_Curve.hxx>
55 #include <Geom2dAdaptor_Curve.hxx>
56
57 #include <TColGeom_Array2OfBezierSurface.hxx>
58 #include <TColgp_Array1OfPnt.hxx>
59 #include <TColgp_Array2OfPnt.hxx>
60 #include <TColStd_Array1OfReal.hxx>
61 #include <TColStd_Array2OfReal.hxx>
62 #include <TColStd_Array1OfInteger.hxx>
63 #include <TColStd_HArray1OfInteger.hxx>
64 #include <TColStd_HArray1OfReal.hxx>
65 #include <TColStd_HArray2OfReal.hxx>
66
67 #include <ElSLib.hxx>
68 #include <ElCLib.hxx>
69 #include <Precision.hxx>
70 #include <Convert_CompBezierCurvesToBSplineCurve.hxx>
71 #include <GeomConvert.hxx>
72 #include <GeomConvert_BSplineCurveToBezierCurve.hxx>
73 #include <GeomConvert_BSplineSurfaceToBezierSurface.hxx>
74 #include <GeomConvert_CompBezierSurfacesToBSplineSurface.hxx>
75 #include <Geom2dConvert.hxx>
76 #include <Geom2dConvert_BSplineCurveToBezierCurve.hxx>
77 #include <GeomLProp_SLProps.hxx>
78
79
80 #include <DrawTrSurf_BezierSurface.hxx>
81 #include <DrawTrSurf_BSplineSurface.hxx>
82 #include <GeomConvert_ApproxSurface.hxx>
83 #include <GeomLib_Tool.hxx>
84 #include <TopoDS_Shape.hxx>
85 #include <DBRep.hxx>
86
87 //#ifdef WNT
88 #include <stdio.h>
89 #ifdef WNT
90 //#define strcasecmp strcmp Already defined
91 Standard_IMPORT Draw_Viewer dout;
92 #endif
93 #ifdef HAVE_STRINGS_H
94 # include <strings.h>
95 #endif
96
97
98
99
100 //=======================================================================
101 //function : compute min max radius of curvature on a surface
102 //purpose  : 
103 //=======================================================================
104 static Standard_Integer surface_radius (Draw_Interpretor& di,
105                                         Standard_Integer n, 
106                                         const char** a)
107 {
108   Standard_Integer report_curvature = 0 ;
109   Standard_Real UParameter,VParameter,radius,tolerance = 1.0e-7 ;
110
111   if (n <  4) return 1;
112   if (n >= 6) report_curvature = 1 ;
113
114   UParameter = Draw::Atof(a[2]);
115   VParameter = Draw::Atof(a[3]);
116   Handle(Geom_Surface) SurfacePtr = DrawTrSurf::GetSurface(a[1]);
117   if (!SurfacePtr.IsNull()) {
118     GeomLProp_SLProps myProperties(SurfacePtr,
119                                    UParameter,
120                                    VParameter,
121                                    2,
122                                    tolerance);
123     if (myProperties.IsCurvatureDefined()) {
124       radius = myProperties.MinCurvature();
125       
126       if (report_curvature) Draw::Set(a[4],radius);
127       
128       if (Abs(radius) > tolerance) { 
129         radius = 1.0e0/ radius ;
130         di << "Min Radius of Curvature : " << radius  << "\n";
131       }
132       else {
133         di << "Min Radius of Curvature :  infinite" << "\n";
134       }
135     
136       radius = myProperties.MaxCurvature();
137       if (report_curvature) Draw::Set(a[5],radius);
138       if (Abs(radius) > tolerance)  { 
139         radius = 1.0e0/ radius;
140         di << "Max Radius of Curvature : " << radius  << "\n";
141       }
142       else
143         di << "Min Radius of Curvature :  infinite" << "\n";
144     }
145     else {
146       di << "Curvature not defined." << "\n";
147     }
148   }
149   else {
150     return 1;
151   }
152   return 0;
153 }
154
155
156 //=======================================================================
157 //function : anasurface
158 //purpose  : 
159 //=======================================================================
160
161 static Standard_Integer anasurface (Draw_Interpretor& ,
162                                     Standard_Integer  n, 
163                                     const char** a)
164 {
165   if (n < 2) return 1;
166   gp_Ax3 loc;
167
168   Standard_Integer i;
169
170   if (n < 5) {
171     loc = gp_Ax3(gp_Pnt(0,0,0),gp_Dir(0,0,1),gp_Dir(1,0,0));
172     i = 2;
173   }
174   else if (n < 8) {
175     loc = gp_Ax3(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
176                  gp_Dir(0,0,1),gp_Dir(1,0,0));
177     i = 5;
178   }
179   else if (n < 11) {
180     loc = gp_Ax3(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
181                  gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])));
182     i = 8;
183   }
184   else if (n < 14) {
185     loc = gp_Ax3(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4])),
186                  gp_Dir(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7])),
187                  gp_Dir(Draw::Atof(a[8]),Draw::Atof(a[9]),Draw::Atof(a[10])));
188     i = 11;
189   }
190   else
191     return 1;
192
193   Handle(Geom_Geometry) result;
194
195   if (!strcasecmp(a[0],"plane")) {
196     Handle(Geom_Plane) C = new Geom_Plane(loc);
197     result = C;
198   }
199   else {
200     if (i >= n) return 1;
201     Standard_Real par1 = Draw::Atof(a[i]);
202     
203     if (!strcasecmp(a[0],"cylinder")) {
204       Handle(Geom_CylindricalSurface) C = 
205         new Geom_CylindricalSurface(loc,par1);
206       result = C;
207     }
208     
209     else if (!strcasecmp(a[0],"sphere")) {
210       Handle(Geom_SphericalSurface) C = 
211         new Geom_SphericalSurface(loc,par1);
212       result = C;
213     }
214     
215     else {
216       if (i+1 >= n) return 1;
217       Standard_Real par2 = Draw::Atof(a[i+1]);
218       
219       if (!strcasecmp(a[0],"cone")) {
220         par1 *= (M_PI / 180.0);
221         Handle(Geom_ConicalSurface) C =
222           new Geom_ConicalSurface(loc,par1,par2);
223         result = C;
224       }
225     
226       else if (!strcasecmp(a[0],"torus")) {
227         Handle(Geom_ToroidalSurface) C =
228           new Geom_ToroidalSurface(loc,par1,par2);
229         result = C;
230       }
231     }    
232   }
233
234   DrawTrSurf::Set(a[1],result);
235   return 0;
236 }
237
238
239 //=======================================================================
240 //function : polesurface
241 //purpose  : 
242 //=======================================================================
243
244 static Standard_Integer polesurface (Draw_Interpretor& , Standard_Integer n, const char** a)
245 {
246   Standard_Integer k,j,i;
247
248
249   if (n < 4) return 1;
250
251   if (!strcasecmp(a[0],"beziersurf")) {
252     
253     Standard_Integer nup = Draw::Atoi(a[2]);
254     Standard_Integer nvp = Draw::Atoi(a[3]);
255     if (nup * nvp == 0) return 1;
256     
257     i = (n - 4) / (nup * nvp);
258     if (i < 3 || i > 4) return 1;
259     Standard_Boolean hasw = i == 4;
260     
261     TColgp_Array2OfPnt poles(1,nup,1,nvp);
262     TColStd_Array2OfReal weights(1,nup,1,nvp);
263     
264     k = 4;
265     for (j = 1; j <= nvp; j++) {
266       for (i = 1; i <= nup; i++) {
267         poles(i, j).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1]),Draw::Atof(a[k+2]));
268         k += 3;
269         if (hasw) {
270           weights(i, j) = Draw::Atof(a[k]);
271           k++;
272         }
273       }
274     }
275     
276     Handle(Geom_BezierSurface) result;
277     if (hasw)
278       result = new Geom_BezierSurface(poles,weights);
279     else
280       result = new Geom_BezierSurface(poles);
281
282     DrawTrSurf::Set(a[1],result);
283   }
284
285   else {
286     Standard_Integer udeg = Draw::Atoi(a[2]);
287     Standard_Integer nbuk = Draw::Atoi(a[3]);
288
289     Standard_Boolean uper = (*a[0] == 'u') || (*(a[0]+1) == 'u');
290     Standard_Boolean vper = (*a[0] == 'v') || (*(a[0]+1) == 'v');
291
292     TColStd_Array1OfReal    uk   (1, nbuk);
293     TColStd_Array1OfInteger umult(1, nbuk);
294     k = 4;
295     Standard_Integer SigmaU = 0;
296     for (i = 1; i<=nbuk; i++) {
297       uk( i) = Draw::Atof(a[k]);
298       k++;
299       umult( i) = Draw::Atoi(a[k]);
300       SigmaU += umult(i);
301       k++;
302     }
303
304     Standard_Integer vdeg = Draw::Atoi(a[k]);
305     k++;
306     Standard_Integer nbvk = Draw::Atoi(a[k]);
307     k++;
308
309     TColStd_Array1OfReal    vk   (1, nbvk);
310     TColStd_Array1OfInteger vmult(1, nbvk);
311     Standard_Integer SigmaV = 0;
312     for (i = 1; i<=nbvk; i++) {
313       vk( i) = Draw::Atof(a[k]);
314       k++;
315       vmult( i) = Draw::Atoi(a[k]);
316       SigmaV += vmult(i);
317       k++;
318     }
319
320     Standard_Integer nup,nvp;
321     if (uper)
322       nup = SigmaU - umult(nbuk);
323     else
324       nup = SigmaU - udeg  -1;
325     if (vper)
326       nvp = SigmaV - vmult(nbvk);
327     else
328       nvp = SigmaV - vdeg  -1;
329     TColgp_Array2OfPnt   poles  (1, nup, 1, nvp);
330     TColStd_Array2OfReal weights(1, nup, 1, nvp);
331     
332     for (j = 1; j <= nvp; j++) {
333       for (i = 1; i <= nup; i++) {
334         poles(i, j).SetCoord(Draw::Atof(a[k]),Draw::Atof(a[k+1]),Draw::Atof(a[k+2]));
335         k += 3;
336         weights(i, j) = Draw::Atof(a[k]);
337         k++;
338       }
339     }
340     
341     Handle(Geom_BSplineSurface) result =
342       new Geom_BSplineSurface(poles, weights,
343                               uk   , vk     ,
344                               umult, vmult  ,
345                               udeg , vdeg   ,
346                               uper , vper   );
347
348     DrawTrSurf::Set(a[1],result);
349   }
350   
351   return 0;
352 }
353
354 //=======================================================================
355 //function : algosurface
356 //purpose  : 
357 //=======================================================================
358
359 static Standard_Integer algosurface (Draw_Interpretor& , Standard_Integer n, const char** a)
360 {
361   if (n < 5) return 1;
362
363   Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[2]);
364   if (GC.IsNull()) return 1;
365
366   gp_Dir D;
367   gp_Pnt P;
368
369   if (!strcasecmp(a[0],"extsurf")) {
370     D.SetCoord(Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5]));
371     Handle(Geom_SurfaceOfLinearExtrusion) result =
372       new Geom_SurfaceOfLinearExtrusion(GC,D);
373
374     DrawTrSurf::Set(a[1],result);
375
376   }
377   else if (!strcasecmp(a[0],"revsurf")) {
378     if (n<8) return 1;
379     P.SetCoord(Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5]));
380     D.SetCoord(Draw::Atof(a[6]),Draw::Atof(a[7]),Draw::Atof(a[8]));
381     
382     Handle(Geom_SurfaceOfRevolution) result =
383       new Geom_SurfaceOfRevolution(GC,gp_Ax1(P,D));
384
385     DrawTrSurf::Set(a[1],result);
386
387   }
388
389   return 0;
390
391 }
392
393
394
395 //=======================================================================
396 //function : trimming
397 //purpose  : 
398 //=======================================================================
399
400 static Standard_Integer trimming (Draw_Interpretor& , 
401                                   Standard_Integer n, const char** a)
402 {
403   if (n < 3) return 1;
404
405   Handle(Geom_Curve)   GC   = DrawTrSurf::GetCurve(a[2]);
406   Handle(Geom2d_Curve) GC2d = DrawTrSurf::GetCurve2d(a[2]);
407   Handle(Geom_Surface) GS   = DrawTrSurf::GetSurface(a[2]);
408
409   if (n == 3) {
410     if (!GC.IsNull()) {
411       Handle(Geom_TrimmedCurve) T = Handle(Geom_TrimmedCurve)::DownCast(GC);
412       if (!T.IsNull()) GC = T->BasisCurve();
413       DrawTrSurf::Set(a[1],GC);
414     }
415     else if (!GC2d.IsNull()) {
416       Handle(Geom2d_TrimmedCurve) T = Handle(Geom2d_TrimmedCurve)::DownCast(GC2d);
417       if (!T.IsNull()) GC2d = T->BasisCurve();
418       DrawTrSurf::Set(a[1],GC2d);
419     }
420     else if (!GS.IsNull()) {
421       Handle(Geom_RectangularTrimmedSurface) T = Handle(Geom_RectangularTrimmedSurface)::DownCast(GS);
422       if (!T.IsNull()) GS = T->BasisSurface();
423       DrawTrSurf::Set(a[1],GS);
424     }
425     return 0;
426   }
427         
428   if (n < 5) return 1;
429
430   Standard_Real u1 = Draw::Atof(a[3]);
431   Standard_Real u2 = Draw::Atof(a[4]);
432
433   Handle(Geom_Geometry) result;
434   Handle(Geom2d_Curve) result2d;
435
436   if (!strcasecmp(a[0],"trim")) {
437     if (!GS.IsNull()) {
438       if (n<7) return 1;
439       result =
440         new Geom_RectangularTrimmedSurface(GS,u1,u2,Draw::Atof(a[5]),Draw::Atof(a[6]));
441     }
442     else if (!GC.IsNull()) {
443       result = new Geom_TrimmedCurve(GC, u1, u2);
444     }
445     else if (!GC2d.IsNull()) {
446       result2d = new Geom2d_TrimmedCurve(GC2d, u1, u2);
447     }
448     else
449       return 1;
450   }
451   else {
452     if (GS.IsNull()) return 1;
453     result =  new Geom_RectangularTrimmedSurface(GS,u1,u2,
454                                                  !strcasecmp(a[0],"trimu"));
455   }
456
457   if (!result.IsNull())
458     DrawTrSurf::Set(a[1], result);
459   else
460     DrawTrSurf::Set(a[1],result2d);
461   
462   return 0;
463 }
464
465 //=======================================================================
466 //function : converting
467 //purpose  : 
468 //=======================================================================
469
470 static Standard_Integer converting(Draw_Interpretor& , Standard_Integer n, const char ** a)
471 {
472   if ( n < 3) return 1;
473
474   Convert_ParameterisationType 
475     Parameterisation = Convert_TgtThetaOver2 ;
476   if (strcmp(a[n-1], "qa") == 0) {
477     Parameterisation = Convert_QuasiAngular ;
478   }
479   else if (strcmp(a[n-1], "c1") == 0) {
480     Parameterisation = Convert_RationalC1 ;
481   }
482   else if (strcmp (a[n-1], "s1") == 0) {
483     Parameterisation = Convert_TgtThetaOver2_1 ;
484   } 
485   else if (strcmp (a[n-1], "s2") == 0) {
486     Parameterisation = Convert_TgtThetaOver2_2;
487   }
488   else if (strcmp (a[n-1], "s3") == 0) {
489     Parameterisation = Convert_TgtThetaOver2_3 ;
490   }
491   else if (strcmp (a[n-1], "s4") == 0) {
492     Parameterisation = Convert_TgtThetaOver2_4 ;
493   }
494   else if (strcmp (a[n-1], "po") == 0) {
495     Parameterisation = Convert_Polynomial;
496   }
497
498   Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[2]);
499   if ( GC.IsNull()) {
500     Handle(Geom_Surface) GS = DrawTrSurf::GetSurface(a[2]);
501     if ( GS.IsNull()) {
502       Handle(Geom2d_Curve) G2d = DrawTrSurf::GetCurve2d(a[2]);
503       if ( G2d.IsNull()) {
504         return 1;
505       }
506       else {
507         G2d = Geom2dConvert::CurveToBSplineCurve(G2d,
508                                                  Parameterisation);
509         DrawTrSurf::Set(a[1], G2d);
510       }
511     }
512     else {
513       GS = GeomConvert::SurfaceToBSplineSurface( GS);
514       DrawTrSurf::Set(a[1], GS);
515     }
516   }
517   else {
518     GC = GeomConvert::CurveToBSplineCurve( GC,
519                                           Parameterisation);
520     DrawTrSurf::Set(a[1], GC);
521   }
522
523   return 0;
524 }
525
526
527 //=======================================================================
528 //function : tobezier
529 //purpose  : 
530 //=======================================================================
531
532 static Standard_Integer tobezier(Draw_Interpretor& di,
533                                  Standard_Integer n, const char** a)
534 {
535   if ( n < 3) return 1;
536   Standard_Integer i,j,NbU,NbV,NbArc;
537   char* name = new char[100];
538   
539   Handle(Geom2d_BSplineCurve) C2d = 
540     DrawTrSurf::GetBSplineCurve2d(a[2]);
541   if ( C2d.IsNull()) {
542     Handle(Geom_BSplineCurve) C3d = 
543       DrawTrSurf::GetBSplineCurve(a[2]);
544     if ( C3d.IsNull()) {
545       Handle(Geom_BSplineSurface) S = 
546         DrawTrSurf::GetBSplineSurface(a[2]);
547       if ( S.IsNull()) return 1;
548       if (n == 7) {
549         Standard_Real U1, U2, V1, V2;
550         U1 = Draw::Atof(a[3]);
551         U2 = Draw::Atof(a[4]);
552         V1 = Draw::Atof(a[5]);
553         V2 = Draw::Atof(a[6]);
554         GeomConvert_BSplineSurfaceToBezierSurface 
555           Conv(S, U1, U2, V1, V2, Precision::PConfusion());
556         NbU = Conv.NbUPatches();
557         NbV = Conv.NbVPatches();
558         di << NbU << " X " << NbV << " patches in the result" << "\n";
559         for (i = 1; i <= NbU; i++) {
560           for (j = 1; j <= NbV; j++) {
561             Sprintf(name,"%s_%i_%i",a[1],i,j);
562             char *temp = name ;
563             DrawTrSurf::Set(temp,Conv.Patch(i,j));
564           }
565         }
566       }
567       else {
568         GeomConvert_BSplineSurfaceToBezierSurface Conv(S);
569         NbU = Conv.NbUPatches();
570         NbV = Conv.NbVPatches();
571         di << NbU << " X " << NbV << " patches in the result" << "\n";
572         for (i = 1; i <= NbU; i++) {
573           for (j = 1; j <= NbV; j++) {
574             Sprintf(name,"%s_%i_%i",a[1],i,j);
575             char *temp = name ;
576             DrawTrSurf::Set(temp,Conv.Patch(i,j));
577           }
578         }
579       }
580     }
581     else {
582       if (n==5) {
583         Standard_Real U1, U2;
584         U1 = Draw::Atof(a[3]);
585         U2 = Draw::Atof(a[4]);
586         GeomConvert_BSplineCurveToBezierCurve Conv(C3d, U1, U2, 
587                                                    Precision::PConfusion());
588         NbArc = Conv.NbArcs();
589         di << NbArc << " arcs in the result" << "\n";
590         for (i = 1; i <= NbArc; i++) {
591           Sprintf(name,"%s_%i",a[1],i);
592           char *temp = name ;
593           DrawTrSurf::Set(temp,Conv.Arc(i));
594         }
595       }
596       else {
597         GeomConvert_BSplineCurveToBezierCurve Conv(C3d);
598         NbArc = Conv.NbArcs();
599         di << NbArc << " arcs in the result" << "\n";
600         for (i = 1; i <= NbArc; i++) {
601           Sprintf(name,"%s_%i",a[1],i);
602           char *temp = name ;
603           DrawTrSurf::Set(temp,Conv.Arc(i));
604         }
605       }
606     }
607   }
608   else {
609     if (n==5) {
610       Standard_Real U1, U2;
611       U1 = Draw::Atof(a[3]);
612       U2 = Draw::Atof(a[4]);
613       Geom2dConvert_BSplineCurveToBezierCurve Conv(C2d, U1, U2, 
614                                                    Precision::PConfusion());
615       NbArc = Conv.NbArcs();
616       di << NbArc << " arcs in the result" << "\n";
617       for (i = 1; i <= NbArc; i++) {
618         Sprintf(name,"%s_%i",a[1],i);
619         char *temp = name ;
620         DrawTrSurf::Set(temp,Conv.Arc(i));
621       }
622     }
623     else {
624       Geom2dConvert_BSplineCurveToBezierCurve Conv(C2d);
625       NbArc = Conv.NbArcs();
626       di << NbArc << " arcs in the result" << "\n";
627       for (i = 1; i <= NbArc; i++) {
628         Sprintf(name,"%s_%i",a[1],i);
629         char *temp = name ;
630         DrawTrSurf::Set(temp,Conv.Arc(i));
631       }
632     }
633   }
634
635   return 0;
636 }
637
638 //=======================================================================
639 //function : convbz
640 //purpose  : 
641 //=======================================================================
642
643 static Standard_Integer convbz(Draw_Interpretor& di,
644                                  Standard_Integer n, const char** a)
645 {
646   if ( n < 4) return 1;
647
648   Standard_Integer ii, jj, kk=0, NbU, NbV;
649   Standard_Real Tol = Precision::Confusion();
650   
651   NbU = Draw::Atoi(a[2]);
652   if ( (Handle(Geom_Curve)::
653         DownCast(DrawTrSurf::Get(a[3]))).IsNull()) {    
654     // Cas Surfacique
655     NbV = Draw::Atoi(a[3]);
656     if (n<4+NbU*NbV) {
657       di << "The number of bezier surface have to be " << NbU*NbV << "\n";
658       return 1;
659     }
660     TColGeom_Array2OfBezierSurface BZ(1, NbU, 1, NbV);
661     kk = 4;
662     for (jj=1; jj<=NbV; jj++)
663       for(ii=1;ii<=NbU; ii++) {
664         BZ(ii,jj) = 
665           Handle(Geom_BezierSurface)::DownCast(DrawTrSurf::Get(a[kk]));
666         if (BZ(ii,jj).IsNull()) {
667           di << "the Surface " << kk <<"is not a BezierSurface" << "\n";
668           return 1;
669         }
670         kk++;
671       }
672     if (kk<n) Tol = Draw::Atof(a[kk]);
673   
674     GeomConvert_CompBezierSurfacesToBSplineSurface Conv(BZ, Tol);
675     
676     if (! Conv.IsDone()) {
677       di << "Convert Not Done" << "\n";
678       return 1;
679     }
680
681     Handle(Geom_BSplineSurface) BSurf = 
682       new Geom_BSplineSurface(Conv.Poles()->Array2(),
683                               Conv.UKnots()->Array1(),
684                               Conv.VKnots()->Array1(),
685                               Conv.UMultiplicities()->Array1(),
686                               Conv.VMultiplicities()->Array1(),
687                               Conv.UDegree(),
688                               Conv.VDegree());
689
690     DrawTrSurf::Set(a[1], BSurf);
691   }
692   else { // cas de courbes
693     Convert_CompBezierCurvesToBSplineCurve Conv;
694     Handle(Geom_BezierCurve) BZ;
695     for (ii=1, kk=3; ii<=NbU; ii++,kk++) {
696       BZ =  Handle(Geom_BezierCurve)::DownCast(DrawTrSurf::Get(a[kk]));
697       if (BZ.IsNull()) {
698           di << "the curve " << kk <<"is not a BezierCurve" << "\n";
699           return 1;
700         }
701       TColgp_Array1OfPnt Poles(1, BZ->NbPoles());
702       BZ->Poles(Poles);
703       Conv.AddCurve(Poles);
704     }
705
706     Conv.Perform();
707
708     TColgp_Array1OfPnt Poles(1, Conv.NbPoles());
709     Conv.Poles(Poles);
710     TColStd_Array1OfInteger Mults(1, Conv.NbKnots());
711     TColStd_Array1OfReal  Knots(1, Conv.NbKnots());
712     Conv.KnotsAndMults(Knots, Mults);
713     Handle(Geom_BSplineCurve) BS = 
714       new (Geom_BSplineCurve) (Poles, Knots, Mults,
715                                Conv.Degree());
716     DrawTrSurf::Set(a[1], BS);
717   }
718
719     return 0;
720 }
721
722 //=======================================================================
723 //function : approxsurf
724 //purpose  : Approximation d'une Surface par une BSpline non rationnelle
725 //=======================================================================
726
727
728 static Standard_Integer approxsurf(Draw_Interpretor& di, Standard_Integer n, const char** a)
729
730 // " Tolerance (par defaut 0.1mm) " 
731   Standard_Real Tol = 1.e-4;
732 // " Ordres de continuites : 0, 1 ou 2 (par defaut 1)" 
733   GeomAbs_Shape myUCont = GeomAbs_C1, myVCont = GeomAbs_C1;
734 // " Degre maximum des carreaux de Bezier 14 par defaut "
735   Standard_Integer degU = 14, degV = 14;
736 // " Nombre max de carreaux (par defaut 10)" 
737   Standard_Integer nmax = 16;
738 // "Code de precision par defaults"
739   Standard_Integer myPrec = 1;  
740
741   if ( n>10 || n<3) return 1;
742
743   if (n>3) Tol = Max(Draw::Atof(a[3]),1.e-10);
744
745   if (n==5)  return 1;
746   
747   if (n>5) {
748     if (Draw::Atoi(a[4]) == 0) myUCont = GeomAbs_C0;
749     if (Draw::Atoi(a[4]) == 2) myUCont = GeomAbs_C2;
750     if (Draw::Atoi(a[5]) == 0) myVCont = GeomAbs_C0;
751     if (Draw::Atoi(a[5]) == 2) myVCont = GeomAbs_C2;
752   }
753
754   if (n==7)  return 1;
755
756   if (n>7) {
757     ( degU = (Draw::Atoi(a[6])));
758     ( degV = (Draw::Atoi(a[7])));
759     if ((degU<1) || (degU>24)) degU = 14;
760     if ((degV<1) || (degV>24)) degV = 14; 
761   }  
762
763   if (n>8) nmax = Draw::Atoi(a[8]);
764   if (n>9) myPrec =  Draw::Atoi(a[9]);
765
766   Handle(Geom_Surface) surf = DrawTrSurf::GetSurface(a[2]);
767   if (surf.IsNull()) return 1;  
768   GeomConvert_ApproxSurface myApprox(surf,Tol,myUCont,myVCont,degU,degV,nmax,myPrec);
769   if ( myApprox.HasResult()) DrawTrSurf::Set(a[1], myApprox.Surface());
770   di<<a[1]<<"\n";
771   return 0;
772 }
773
774 //=======================================================================
775 //function : offseting
776 //purpose  : 
777 //=======================================================================
778
779 static Standard_Integer offseting (Draw_Interpretor& ,
780                                    Standard_Integer n, const char** a)
781 {
782   if (n < 4) return 1;
783
784   // test the Geom2d curve
785   Handle(Geom2d_Curve) C2d = DrawTrSurf::GetCurve2d(a[2]);
786   if (!C2d.IsNull()) {
787     Handle(Geom2d_OffsetCurve) OC = new Geom2d_OffsetCurve(C2d,Draw::Atof(a[3]));
788     DrawTrSurf::Set(a[1],OC);
789     return 0;
790   }
791
792   Standard_Boolean yasurf = Standard_False;
793
794   Handle(Geom_Curve) GC = DrawTrSurf::GetCurve(a[2]);
795   Handle(Geom_Surface) GS;
796   if (GC.IsNull()) {
797     GS = DrawTrSurf::GetSurface(a[2]);
798     if (GS.IsNull())
799       return 1;
800     yasurf = Standard_True;
801   }
802
803   Standard_Real dist = Draw::Atof(a[3]);
804
805   Handle(Geom_Geometry) result;
806
807   if (yasurf) {
808     Handle(Geom_OffsetSurface) GO = new Geom_OffsetSurface(GS,dist);
809     result = GO;
810   }
811   else {
812     if (n < 7) return 1;
813     gp_Dir D(Draw::Atof(a[4]),Draw::Atof(a[5]),Draw::Atof(a[6]));
814     Handle(Geom_OffsetCurve) GT = new Geom_OffsetCurve(GC, dist, D);
815     result = GT;
816   }
817
818   DrawTrSurf::Set(a[1], result);
819   return 0;
820 }
821
822 //=======================================================================
823 //function : sreverse
824 //purpose  : 
825 //=======================================================================
826
827 static Standard_Integer sreverse (Draw_Interpretor& , Standard_Integer n, const char** a)
828 {
829   if (n < 2) return 1;
830
831   Standard_Integer i;
832   for (i = 1; i < n; i++) {
833
834     Handle(Geom_Surface) GS = DrawTrSurf::GetSurface(a[i]);
835     if (!GS.IsNull()) {
836       if (*a[0] == 'u')
837         GS->UReverse();
838       else
839         GS->VReverse();
840       Draw::Repaint();
841     }
842   }
843
844   return 0;
845 }
846
847 //=======================================================================
848 //function : iso
849 //purpose  : 
850 //=======================================================================
851
852 static Standard_Integer iso (Draw_Interpretor& , Standard_Integer n, const char** a)
853 {
854   if (n < 4) return 1;
855
856   Handle(Geom_Curve) C;
857   Standard_Real par = Draw::Atof(a[3]);
858   Handle(Geom_Surface) GS = DrawTrSurf::GetSurface(a[2]);
859   if (!GS.IsNull()) {
860     if (*a[0] == 'u')
861       C = GS->UIso(par);
862     else
863       C = GS->VIso(par);
864     DrawTrSurf::Set(a[1],C);
865   }
866   
867   return 0;
868 }
869
870
871 //=======================================================================
872 //function : value
873 //purpose  : 
874 //=======================================================================
875
876 static Standard_Integer value (Draw_Interpretor& ,
877                                Standard_Integer n, const char** a)
878 {
879   if (n < 5) return 1;
880
881   Handle(Geom_Surface) GS = DrawTrSurf::GetSurface(a[1]);
882   if (GS.IsNull()) return 1;
883
884   Standard_Real U = Draw::Atof(a[2]);
885   Standard_Real V = Draw::Atof(a[3]);
886
887   Standard_Boolean DrawPoint = ( n%3 == 2);
888   if ( DrawPoint) n--;
889
890   gp_Pnt P;
891   if (n >= 13) {
892     gp_Vec DU,DV;
893     if (n >= 22) {
894       gp_Vec D2U,D2V,D2UV;
895       GS->D2(U,V,P,DU,DV,D2U,D2V,D2UV);
896       Draw::Set(a[13],D2U.X());
897       Draw::Set(a[14],D2U.Y());
898       Draw::Set(a[15],D2U.Z());
899       Draw::Set(a[16],D2V.X());
900       Draw::Set(a[17],D2V.Y());
901       Draw::Set(a[18],D2V.Z());
902       Draw::Set(a[19],D2UV.X());
903       Draw::Set(a[20],D2UV.Y());
904       Draw::Set(a[21],D2UV.Z());
905     }
906     else
907       GS->D1(U,V,P,DU,DV);
908
909     Draw::Set(a[7],DU.X());
910     Draw::Set(a[8],DU.Y());
911     Draw::Set(a[9],DU.Z());
912     Draw::Set(a[10],DV.X());
913     Draw::Set(a[11],DV.Y());
914     Draw::Set(a[12],DV.Z());
915   }
916   else 
917     GS->D0(U,V,P);
918
919   if ( n > 6) {
920     Draw::Set(a[4],P.X());
921     Draw::Set(a[5],P.Y());
922     Draw::Set(a[6],P.Z());
923   }
924   if ( DrawPoint) {
925     DrawTrSurf::Set(a[n],P);
926   }
927
928   return 0;
929 }
930
931 //=======================================================================
932 //function : movepole
933 //purpose  : 
934 //=======================================================================
935
936 static Standard_Integer movepole (Draw_Interpretor& , Standard_Integer n, const char** a)
937 {
938   if (n < 6) return 1;
939   Standard_Boolean BSpline = Standard_False;
940
941   Handle(Geom_BezierSurface) GBz = DrawTrSurf::GetBezierSurface(a[1]);
942   Handle(Geom_BSplineSurface) GBs;
943   if (GBz.IsNull()) {
944     GBs = DrawTrSurf::GetBSplineSurface(a[1]);
945     if (GBs.IsNull())
946       return 1;
947       BSpline = Standard_True;
948   }
949
950   Standard_Real dx = Draw::Atof(a[n-3]);
951   Standard_Real dy = Draw::Atof(a[n-2]);
952   Standard_Real dz = Draw::Atof(a[n-1]);
953   
954   Standard_Integer nup, nvp;
955   if( !BSpline) {
956     nup = GBz->NbUPoles();
957     nvp = GBz->NbVPoles();
958   }
959   else {
960     nup = GBs->NbUPoles();
961     nvp = GBs->NbVPoles();
962   }
963
964   Standard_Integer FirstRow=0, LastRow=0, FirstCol=0, LastCol=0;
965   // Rem : Row = indice ligne.  -> variation en U. 
966   //       Col = indice colonne.-> variation en V.
967
968   if (!strcasecmp(a[0],"movep")) {
969     if (n<7) return 1;
970     FirstRow = Draw::Atoi(a[2]);
971     FirstCol = Draw::Atoi(a[3]);
972     if ( FirstRow < 1  || FirstRow > nup ||
973          FirstCol < 1  || FirstCol > nvp   ) return 1;
974     LastRow = FirstRow;
975     LastCol = FirstCol;
976   }
977   else if (!strcasecmp(a[0],"moverowp")) {
978     FirstRow = Draw::Atoi(a[2]);
979     if ( FirstRow < 1  || FirstRow > nup ) return 1;
980     LastRow = FirstRow;
981     FirstCol = 1;
982     LastCol  = nvp;
983   }
984   else if (!strcasecmp(a[0],"movecolp")) {
985     FirstCol = Draw::Atoi(a[2]);
986     if ( FirstCol < 1  || FirstCol > nvp ) return 1;
987     LastCol = FirstCol;
988     FirstRow = 1;
989     LastRow  = nup;
990   }
991
992   gp_Pnt P;
993
994   for ( Standard_Integer i = FirstRow; i<= LastRow; i++) {
995     for ( Standard_Integer j = FirstCol; j<= LastCol; j++) {
996       if( !BSpline) {
997         P = GBz->Pole(i,j);
998         P.SetCoord(P.X()+dx, P.Y()+dy, P.Z()+dz);
999         GBz->SetPole(i,j,P);
1000       }
1001       else {
1002         P = GBs->Pole(i,j);
1003         P.SetCoord(P.X()+dx, P.Y()+dy, P.Z()+dz);
1004         GBs->SetPole(i,j,P);
1005       }
1006     }
1007   }
1008
1009   Draw::Repaint();
1010
1011   return 0;
1012 }
1013
1014
1015 //=======================================================================
1016 //function : movepoint
1017 //purpose  : 
1018 //=======================================================================
1019
1020 static Standard_Integer movepoint (Draw_Interpretor& , Standard_Integer n, const char** a)
1021 {
1022   if (n < 7) return 1;
1023
1024   Handle(Geom_BSplineSurface) GBs = DrawTrSurf::GetBSplineSurface(a[1]);
1025   if (GBs.IsNull()) {
1026     return 1;
1027   }
1028
1029   Standard_Real u = Draw::Atof(a[2]);
1030   Standard_Real v = Draw::Atof(a[3]);
1031
1032   Standard_Real dx = Draw::Atof(a[4]);
1033   Standard_Real dy = Draw::Atof(a[5]);
1034   Standard_Real dz = Draw::Atof(a[6]);
1035   
1036   Standard_Integer index1u = 0;
1037   Standard_Integer index2u = 0;
1038   Standard_Integer index1v = 0;
1039   Standard_Integer index2v = 0;
1040
1041   Standard_Integer fmodifu, lmodifu, fmodifv, lmodifv;
1042   if (n == 11) {
1043     index1u = Draw::Atoi(a[7]);
1044     index2u = Draw::Atoi(a[8]);
1045     index1v = Draw::Atoi(a[9]);
1046     index2v = Draw::Atoi(a[10]);
1047   }
1048   else {
1049     index1u = 2;
1050     index2u = GBs->NbUPoles()-1;
1051     index1v = 2;
1052     index2v = GBs->NbVPoles()-1;
1053   }
1054
1055   gp_Pnt p;
1056   GBs->D0(u, v, p);
1057   p.SetCoord(p.X()+dx, p.Y()+dy, p.Z()+dz);
1058   GBs->MovePoint(u, v, p, index1u, index2u, index1v, index2v, fmodifu, lmodifu, fmodifv, lmodifv);
1059   Draw::Repaint();
1060   return 0;
1061 }
1062
1063
1064 //=======================================================================
1065 //function : insertknot
1066 //purpose  : 
1067 //=======================================================================
1068
1069 static Standard_Integer insertknot (Draw_Interpretor& , Standard_Integer n, const char** a)
1070 {
1071   if (n < 3) return 1;
1072
1073   Handle(Geom_BSplineSurface) GBs = DrawTrSurf::GetBSplineSurface(a[1]);
1074
1075   if (GBs.IsNull()) return 1;
1076
1077   Standard_Real    knot=0;
1078   Standard_Integer mult = 0;
1079   Standard_Integer index=0;
1080   if (  !strcasecmp(a[0],"insertuknot") ||
1081         !strcasecmp(a[0],"insertvknot")   ) {
1082     if (n<4) return 1;
1083     knot = Draw::Atof(a[2]);
1084     mult = Draw::Atoi(a[3]);
1085   }
1086   else if (  !strcasecmp(a[0],"remuknot") ||
1087              !strcasecmp(a[0],"remvknot")   ) {
1088     index = Draw::Atoi(a[2]);
1089     if (n>=4) mult  = Draw::Atoi(a[3]);
1090   }
1091
1092   Standard_Real tol = RealLast();
1093
1094   if (!strcasecmp(a[0],"insertuknot")) {
1095     GBs->InsertUKnot(knot,mult,Precision::PConfusion());
1096   }
1097   else if (!strcasecmp(a[0],"insertvknot")) {
1098     GBs->InsertVKnot(knot,mult,Precision::PConfusion());
1099   }
1100   else if (!strcasecmp(a[0],"remuknot")) {
1101     if (n>=5) tol = Draw::Atof(a[4]);
1102     if (!GBs->RemoveUKnot(index,mult,tol)) 
1103       return 1;
1104   }
1105   else if (!strcasecmp(a[0],"remvknot")) {
1106     if (n>=5) tol = Draw::Atof(a[4]);
1107     if (!GBs->RemoveVKnot(index,mult,tol))
1108       return 1;
1109   }
1110
1111   Draw::Repaint();
1112   return 0;
1113 }
1114
1115 //=======================================================================
1116 //function : incdegree
1117 //purpose  : 
1118 //=======================================================================
1119
1120 static Standard_Integer incdegree (Draw_Interpretor& di, Standard_Integer n, const char** a)
1121 {
1122   if (n < 3) return 1;
1123   
1124   Standard_Integer NewDeg = Draw::Atoi(a[2]);
1125   Standard_Boolean BSpline = Standard_False;
1126   
1127   Standard_Integer UDeg=0, VDeg=0;
1128   
1129   Handle(Geom_BezierSurface) GBz = DrawTrSurf::GetBezierSurface(a[1]);
1130   Handle(Geom_BSplineSurface) GBs;
1131   
1132   if (GBz.IsNull()) {
1133     GBs = DrawTrSurf::GetBSplineSurface(a[1]);
1134     if (GBs.IsNull())
1135       return 1;
1136     BSpline = Standard_True;
1137   }
1138   
1139   Standard_Integer Degree=0;
1140   if ( !strcasecmp(a[0],"incudeg")) {
1141     UDeg = NewDeg;
1142     if (BSpline) {
1143       Degree = GBs->UDegree();
1144       VDeg   = GBs->VDegree();
1145     }
1146     else {
1147       Degree = GBz->UDegree();
1148       VDeg   = GBz->VDegree();
1149     }
1150   }  
1151   else if ( !strcasecmp(a[0],"incvdeg")) {
1152     VDeg = NewDeg;
1153     if (BSpline) {
1154       Degree = GBs->VDegree();
1155       UDeg   = GBs->UDegree();
1156     }
1157     else {
1158       Degree = GBz->VDegree();
1159       UDeg   = GBz->UDegree();
1160     }
1161   }
1162   
1163   if (Degree > NewDeg) {
1164     di<<"The Degree must be greater than " << Degree <<"\n";
1165     return 1;
1166   }
1167   
1168   if ( BSpline) {
1169     GBs->IncreaseDegree(UDeg, VDeg);
1170   }
1171   else {
1172     GBz->Increase(UDeg, VDeg);
1173   }
1174
1175   Draw::Repaint();
1176   return 0;
1177 }
1178
1179 //=======================================================================
1180 //function : rempole
1181 //purpose  : 
1182 //=======================================================================
1183
1184 static Standard_Integer rempole (Draw_Interpretor& di, Standard_Integer n, const char** a)
1185 {
1186   if (n < 3) return 1;
1187   
1188   Standard_Integer NewIndex = Draw::Atoi(a[2]);
1189   Standard_Boolean BSpline  = Standard_False;
1190   
1191   Handle(Geom_BezierSurface) GBz = DrawTrSurf::GetBezierSurface(a[1]);
1192   Handle(Geom_BSplineSurface) GBs;
1193   
1194   if (GBz.IsNull()) {
1195     GBs = DrawTrSurf::GetBSplineSurface(a[1]);
1196     if (GBs.IsNull())
1197       return 1;
1198     BSpline = Standard_True;
1199   }
1200   
1201   if ( !strcasecmp(a[0],"remrowpole")) {
1202     if ( BSpline) {
1203       di << " Error : Cannot remove a polerow on a BSplineSurface " << "\n";
1204     }
1205     else {
1206       GBz->RemovePoleRow(NewIndex);
1207     }
1208   }
1209   else if ( !strcasecmp(a[0],"remcolpole")) {
1210     if ( BSpline) {
1211       di << " Error : Cannot remove a polecol on a BSplineSurface " << "\n";
1212     }
1213     else {
1214       GBz->RemovePoleCol(NewIndex);
1215     }
1216   }
1217
1218   Draw::Repaint();
1219   return 0;
1220 }
1221
1222 //=======================================================================
1223 //function : sfindp
1224 //purpose  : 
1225 //=======================================================================
1226
1227 static Standard_Integer sfindp (Draw_Interpretor& , Standard_Integer n, const char** a)
1228 {
1229   if (n < 7) return 1;
1230   Standard_Boolean BSpline = Standard_False;
1231
1232   Handle(Geom_BezierSurface) GBz = DrawTrSurf::GetBezierSurface(a[1]);
1233   Handle(Geom_BSplineSurface) GBs;
1234   if (GBz.IsNull()) {
1235     GBs = DrawTrSurf::GetBSplineSurface(a[1]);
1236     if (GBs.IsNull())
1237       return 1;
1238       BSpline = Standard_True;
1239   }
1240
1241   Standard_Integer UIndex = 0;
1242   Standard_Integer VIndex = 0;
1243   Standard_Integer view = Draw::Atoi(a[2]);
1244   Standard_Real x = Draw::Atof(a[3]);
1245   Standard_Real y = Draw::Atof(a[4]);
1246
1247   Draw_Display d = dout.MakeDisplay(view);
1248   
1249   if( !BSpline) {
1250     Handle(DrawTrSurf_BezierSurface) DBz = 
1251       new DrawTrSurf_BezierSurface(GBz);
1252     DBz->FindPole( x, y, d, 5, UIndex,VIndex);
1253   }
1254   else {
1255     Handle(DrawTrSurf_BSplineSurface) DBs = 
1256       new DrawTrSurf_BSplineSurface(GBs);
1257     DBs->FindPole( x, y, d, 5, UIndex,VIndex);
1258   }
1259
1260   Draw::Set(a[5],UIndex);
1261   Draw::Set(a[6],VIndex);
1262   
1263   return 0;
1264 }
1265
1266
1267 //=======================================================================
1268 //function : ssetperiodic
1269 //purpose  : 
1270 //=======================================================================
1271
1272 static Standard_Integer ssetperiodic (Draw_Interpretor& , Standard_Integer n, const char** a)
1273 {
1274   if (n < 2) return 1;
1275
1276   Standard_Integer i;
1277
1278   if (!strcasecmp(a[0],"setuperiodic")) {
1279     for (i = 1; i < n; i++) {
1280       Handle(Geom_BSplineSurface) 
1281         GBs = DrawTrSurf::GetBSplineSurface(a[i]);
1282       if (!GBs.IsNull()) {
1283         GBs->SetUPeriodic();
1284         Draw::Repaint();
1285       }
1286     }
1287   }
1288   else if (!strcasecmp(a[0],"setvperiodic")){
1289     for (i = 1; i < n; i++) {
1290       Handle(Geom_BSplineSurface) 
1291         GBs = DrawTrSurf::GetBSplineSurface(a[i]);
1292       if (!GBs.IsNull()) {
1293         GBs->SetVPeriodic();
1294         Draw::Repaint();
1295       }
1296     }
1297   }
1298   else if (!strcasecmp(a[0],"setunotperiodic")){
1299     for (i = 1; i < n; i++) {
1300       Handle(Geom_BSplineSurface) 
1301         GBs = DrawTrSurf::GetBSplineSurface(a[i]);
1302       if (!GBs.IsNull()) {
1303         GBs->SetUNotPeriodic();
1304         Draw::Repaint();
1305       }
1306     }
1307   }
1308   else if (!strcasecmp(a[0],"setvnotperiodic")){
1309     for (i = 1; i < n; i++) {
1310       Handle(Geom_BSplineSurface) 
1311         GBs = DrawTrSurf::GetBSplineSurface(a[i]);
1312       if (!GBs.IsNull()) {
1313         GBs->SetVNotPeriodic();
1314         Draw::Repaint();
1315       }
1316     }
1317   }
1318   return 0;
1319 }
1320
1321 //=======================================================================
1322 //function : exchuv
1323 //purpose  : 
1324 //=======================================================================
1325
1326 static Standard_Integer exchuv (Draw_Interpretor& , Standard_Integer n, const char** a)
1327 {
1328   if (n < 2) return 1;
1329
1330   Standard_Integer i;
1331   for (i = 1; i < n; i++) {
1332
1333     Handle(Geom_BSplineSurface) GBs = DrawTrSurf::GetBSplineSurface(a[i]);
1334     if (!GBs.IsNull()) {
1335       GBs->ExchangeUV();
1336       Draw::Repaint();
1337     }
1338     else {
1339       Handle(Geom_BezierSurface) GBz = DrawTrSurf::GetBezierSurface(a[i]);
1340       if (!GBz.IsNull()) {
1341         GBz->ExchangeUV();
1342         Draw::Repaint();
1343       }
1344     }
1345   }
1346
1347   return 0;
1348 }
1349
1350 //=======================================================================
1351 //function : segsur
1352 //purpose  : 
1353 //=======================================================================
1354
1355 static Standard_Integer segsur (Draw_Interpretor& , Standard_Integer n, const char** a)
1356 {
1357   if (n < 6) return 1;
1358
1359   Handle(Geom_BezierSurface) GBz = DrawTrSurf::GetBezierSurface(a[1]);
1360   Handle(Geom_BSplineSurface) GBs;
1361   if (GBz.IsNull()) {
1362     GBs = DrawTrSurf::GetBSplineSurface(a[1]);
1363     if (GBs.IsNull())
1364       return 1;
1365     GBs->Segment(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5])); 
1366   }
1367   else {
1368     GBz->Segment(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5]));
1369   }
1370
1371   Draw::Repaint();
1372   return 0;
1373 }
1374
1375 static Standard_Integer compBsplSur (Draw_Interpretor& , Standard_Integer n, const char** a)
1376 {
1377   if (n < 2) 
1378   {
1379     cout<<"Invalid number of parameters"<<endl;
1380     return 1;
1381   }
1382
1383   Handle(Geom_BSplineSurface) GBs1 = DrawTrSurf::GetBSplineSurface(a[1]);
1384   Handle(Geom_BSplineSurface) GBs2 = DrawTrSurf::GetBSplineSurface(a[2]);
1385   if (GBs1.IsNull() || GBs2.IsNull()) {
1386     cout<<"Invalid surface"<<endl;
1387     return 1;
1388   }
1389    
1390   Standard_Real aU11,aU12,aV11,aV12;
1391   GBs1->Bounds(aU11,aU12,aV11,aV12);
1392   
1393   Standard_Real aU21,aU22,aV21,aV22;
1394   GBs2->Bounds(aU21,aU22,aV21,aV22);
1395   
1396   Standard_Real aUmin = Max(aU11,aU21);
1397   Standard_Real aUmax = Min(aU12,aU22);
1398   
1399   Standard_Real aVmin = Max(aV11,aV21);
1400   Standard_Real aVmax = Min(aV12,aV22);
1401   
1402   Standard_Integer nbP = 100;
1403   Standard_Real aStepU = (aUmax - aUmin)/nbP;
1404   Standard_Real aStepV = (aVmax - aVmin)/nbP;
1405   Standard_Integer nbErr =0;
1406   Standard_Integer i =1;
1407   for( ; i <= nbP +1; i++)
1408   {
1409     Standard_Real aU = aUmin + aStepU*(i-1);
1410     Standard_Integer j =1;
1411     for( ; j <= nbP +1; j++)
1412     {
1413       Standard_Real aV = aVmin + aStepV*(j-1);
1414       gp_Pnt aP1 = GBs1->Value(aU,aV);
1415       gp_Pnt aP2 = GBs2->Value(aU,aV);
1416       Standard_Real aDist = aP1.SquareDistance(aP2);
1417       if(aDist > Precision::SquareConfusion())
1418       {
1419         nbErr++;
1420         Standard_Real aD = sqrt(aDist);
1421         cout<<"Surfaces differ for U,V,Dist: "<<aU<<" "<<aV<<" "<<aD<<endl;
1422       }
1423     }
1424   }
1425   
1426   
1427   Draw::Repaint();
1428   return 0;
1429 }
1430
1431 //=======================================================================
1432 //function : setuvorigin
1433 //purpose  : 
1434 //=======================================================================
1435
1436 static Standard_Integer setuvorigin (Draw_Interpretor& , Standard_Integer n, const char** a)
1437 {
1438   if (n < 3) return 1;
1439
1440   Handle(Geom_BSplineSurface) GBs = DrawTrSurf::GetBSplineSurface(a[1]);
1441   if (GBs.IsNull())
1442     return 1;
1443   if ( !strcasecmp(a[0],"setuorigin")) {
1444     GBs->SetUOrigin(Draw::Atoi(a[2])); 
1445   }
1446   else if ( !strcasecmp(a[0],"setvorigin")) {
1447     GBs->SetVOrigin(Draw::Atoi(a[2])); 
1448   }
1449   else 
1450     return 1;
1451
1452   Draw::Repaint();
1453   return 0;
1454 }
1455
1456
1457 //=======================================================================
1458 //function : parameters
1459 //purpose  : 
1460 //=======================================================================
1461
1462 static Standard_Integer parameters (Draw_Interpretor& di, Standard_Integer n, const char** a)
1463 {
1464   if(n == 8)
1465     { 
1466       // try to find parameters on a Surface
1467       Handle(Geom_Surface) S = DrawTrSurf::GetSurface(a[1]);
1468       if( S.IsNull() ) { di << "Unknown surface" << "\n"; return 1; }
1469       gp_Pnt P(Draw::Atof(a[2]), Draw::Atof(a[3]), Draw::Atof(a[4]));
1470       Standard_Real Tol = Draw::Atof(a[5]), U = 0., V = 0.;
1471       Standard_Boolean res = GeomLib_Tool::Parameters(S,P,Tol,U,V);
1472
1473       Draw::Set(a[6],U);
1474       Draw::Set(a[7],V);
1475
1476       if( !res ) { di << "Wrong point" << "\n"; return 1; }
1477     }
1478   else if(n == 7)
1479     {
1480       // try to find parameters on a 3d Curve
1481       Handle(Geom_Curve) C = DrawTrSurf::GetCurve(a[1]);
1482       if( C.IsNull() ) { di << "Unknown curve" << "\n"; return 1; }
1483       gp_Pnt P(Draw::Atof(a[2]), Draw::Atof(a[3]), Draw::Atof(a[4]));
1484       Standard_Real Tol = Draw::Atof(a[5]), U = 0.;
1485       Standard_Boolean res = GeomLib_Tool::Parameter(C,P,Tol,U);
1486     
1487       Draw::Set(a[6],U);
1488
1489     if( !res ) { di << "Wrong point" << "\n"; return 1; }
1490     }
1491   else if(n == 6)
1492     {
1493       // try to find parameters on a 2d Curve
1494       Handle(Geom2d_Curve) C = DrawTrSurf::GetCurve2d(a[1]);
1495       if( C.IsNull() ) { di << "Unknown curve 2d" << "\n";  return 1; }
1496       gp_Pnt2d P(Draw::Atof(a[2]), Draw::Atof(a[3]));
1497       Standard_Real Tol = Draw::Atof(a[4]), U = 0.;
1498       Standard_Boolean res = GeomLib_Tool::Parameter(C,P,Tol,U);
1499     
1500       Draw::Set(a[5],U);
1501
1502       if( !res ) { di << "Wrong point" << "\n"; return 1; }
1503     }
1504   else
1505     {
1506       di << "Invalid parameters!" << "\n";
1507       di << "Usage:" << "\n";
1508       di << "parameters Surf X Y Z Tol U V" << "\n";
1509       di << "parameters Curv X Y Z Tol U" << "\n";
1510       di << "parameters Curv2d X Y Tol U" << "\n";
1511       return 1;
1512     }
1513
1514   return 0;
1515 }
1516
1517
1518 //=======================================================================
1519 //function : bounds
1520 //purpose  : 
1521 //=======================================================================
1522
1523 Standard_Integer bounds(Draw_Interpretor&, Standard_Integer n, const char** a)
1524 {
1525   Standard_Real U1, U2, V1, V2;
1526   if ( n == 4) {  // compute on a curve or a 2d curve
1527     Handle(Geom_Curve) C3d = DrawTrSurf::GetCurve(a[1]);
1528     if ( C3d.IsNull()) { // 2dcurve
1529       Handle(Geom2d_Curve) C2d = DrawTrSurf::GetCurve2d(a[1]);
1530       if ( C2d.IsNull()) return 1;
1531       U1 = C2d->FirstParameter();
1532       U2 = C2d->LastParameter();
1533     }
1534     else { // 3dcurve
1535       U1 = C3d->FirstParameter();
1536       U2 = C3d->LastParameter();
1537     }
1538     Draw::Set(a[2],U1);
1539     Draw::Set(a[3],U2);
1540   }
1541   else if ( n == 6) { // compute on a Surface
1542     Handle(Geom_Surface) S = DrawTrSurf::GetSurface(a[1]);
1543     if ( S.IsNull()) return 1;
1544     S->Bounds(U1,U2,V1,V2);
1545
1546     Draw::Set(a[2],U1);
1547     Draw::Set(a[3],U2);
1548     Draw::Set(a[4],V1);
1549     Draw::Set(a[5],V2);
1550   }
1551
1552   return 0;
1553 }
1554
1555 //=======================================================================
1556 //function : SurfaceCommands
1557 //purpose  : 
1558 //=======================================================================
1559
1560
1561 void  GeomliteTest::SurfaceCommands(Draw_Interpretor& theCommands)
1562 {
1563   static Standard_Boolean loaded = Standard_False;
1564   if (loaded) return;
1565   loaded = Standard_True;
1566
1567   DrawTrSurf::BasicCommands(theCommands);
1568
1569   const char* g;
1570   // analytic surfaces
1571   g = "GEOMETRY surfaces creation";
1572
1573   theCommands.Add("plane",
1574                   "plane name [x y z [dx dy dz [ux uy uz]]]",
1575                   __FILE__,
1576                   anasurface,g);
1577
1578   theCommands.Add("cone",
1579                   "cone name [x y z [dx dy dz [ux uy uz]]] semi-angle radius",
1580                   __FILE__,
1581                   anasurface,g);
1582
1583   theCommands.Add("cylinder",
1584                   "cylinder name [x y z [dx dy dz [ux uy uz]]]  radius",
1585                   __FILE__,
1586                   anasurface,g);
1587
1588   theCommands.Add("sphere",
1589                   "sphere name [x y z [dx dy dz [ux uy uz]]]  radius",
1590                   __FILE__,
1591                   anasurface,g);
1592
1593   theCommands.Add("torus",
1594                   "torus name [x y z [dx dy dz [ux uy uz]]]  major minor",
1595                   __FILE__,
1596                   anasurface,g);
1597
1598   theCommands.Add("beziersurf",
1599                   "beziersurf name nbupoles nbvpoles pole, [weight]",
1600                   __FILE__,
1601                   polesurface,g);
1602
1603   theCommands.Add("bsplinesurf",
1604                   "bsplinesurf name udegree nbuknots  uknot, umult  vdegree nbvknots vknot, vmult pole, weight",
1605                   __FILE__,
1606                   polesurface,g);
1607
1608   theCommands.Add("upbsplinesurf",
1609                   "bsplinesurf name udegree nbuknots  uknot, umult  vdegree nbvknots vknot, vmult pole, weight",
1610                   __FILE__,
1611                   polesurface,g);
1612
1613   theCommands.Add("vpbsplinesurf",
1614                   "bsplinesurf name udegree nbuknots  uknot, umult  vdegree nbvknots vknot, vmult pole, weight",
1615                   __FILE__,
1616                   polesurface,g);
1617
1618   theCommands.Add("uvpbsplinesurf",
1619                   "bsplinesurf name udegree nbuknots  uknot, umult  vdegree nbvknots vknot, vmult pole, weight",
1620                   __FILE__,
1621                   polesurface,g);
1622
1623   theCommands.Add("extsurf",
1624                   "extsurf name curvename dx dy dz",
1625                   __FILE__,
1626                   algosurface,g);
1627
1628   theCommands.Add("revsurf",
1629                   "revsurf name curvename x y z dx dy dz",
1630                   __FILE__,
1631                   algosurface,g);
1632
1633   theCommands.Add("offset",
1634                   "offset name basename distance [dx dy dz]",
1635                   __FILE__,
1636                   offseting,g);
1637
1638   theCommands.Add("trim",
1639                   "trim newname name [u1 u2 [v1 v2]], no args remove trim",
1640                   __FILE__,
1641                   trimming,g);
1642
1643   theCommands.Add("trimu",
1644                   "trim newname name u1 u2",
1645                   __FILE__,
1646                   trimming,g);
1647
1648   theCommands.Add("trimv",
1649                   "trim newname name v1 v2",
1650                   __FILE__,
1651                   trimming,g);
1652
1653   theCommands.Add("convert",
1654                   "convert result c2d/c3d/surf [qa,c1,s1,s2,s3,s4,po]",
1655                   __FILE__,
1656                   converting,g);
1657
1658   theCommands.Add("tobezier",
1659                   "tobezier result c2d/c3d/surf [ufirst, ulast / ufirst, ulast, vfirst, vlast]",
1660                   __FILE__,
1661                   tobezier,g);
1662
1663   theCommands.Add("convertfrombezier",
1664                   "convertfrombezier result nbu [nbv] bz1 [bz2 .... bzn] [tol]",
1665                   __FILE__,
1666                   convbz,g);
1667
1668   theCommands.Add("approxsurf",
1669                   "approxsurf name surf [Tol [CnU CnV [degU degV [nmax]]]] ",
1670                   __FILE__,
1671                   approxsurf,g);
1672
1673   g = "GEOMETRY Curves and Surfaces modification";
1674
1675   theCommands.Add("ureverse",
1676                   "ureverse name ... ",
1677                   __FILE__,
1678                   sreverse,g);
1679
1680   theCommands.Add("vreverse",
1681                   "vreverse name ... ",
1682                   __FILE__,
1683                   sreverse,g);
1684
1685   theCommands.Add("movep",
1686                   "movep name row col dx dy dz",
1687                   __FILE__,
1688                   movepole,g);
1689
1690   theCommands.Add("moverowp",
1691                   "moverowp name row dx dy dz",
1692                   __FILE__,
1693                   movepole,g);
1694
1695   theCommands.Add("movecolp",
1696                   "movecolp name col dx dy dz",
1697                   __FILE__,
1698                   movepole,g);
1699
1700   theCommands.Add("movepoint",
1701                   "movepoint name u v dx dy dz [index1u index2u index2v index2v",
1702                   __FILE__,
1703                   movepoint,g);
1704
1705   theCommands.Add("insertuknot",
1706                   "insertuknot name knot mult",
1707                   __FILE__,
1708                   insertknot,g);
1709
1710   theCommands.Add("insertvknot",
1711                   "insertvknot name knot mult",
1712                   __FILE__,
1713                   insertknot,g);
1714
1715   theCommands.Add("remuknot",
1716                   "remuknot name index [mult] [tol]",
1717                   __FILE__,
1718                   insertknot,g);
1719   
1720   theCommands.Add("remvknot",
1721                   "remvknot name index [mult] [tol]",
1722                   __FILE__,
1723                   insertknot,g);
1724
1725   theCommands.Add("incudeg",
1726                   "incudeg name degree",
1727                   __FILE__,
1728                   incdegree,g);
1729
1730   theCommands.Add("incvdeg",
1731                   "incvdeg name degree",
1732                   __FILE__,
1733                   incdegree,g);
1734
1735   theCommands.Add("remrowpole",
1736                   "remrowpole name index",
1737                   __FILE__,
1738                   rempole,g);
1739
1740   theCommands.Add("remcolpole",
1741                   "remcolpole name index",
1742                   __FILE__,
1743                   rempole,g);
1744
1745   theCommands.Add("sfindp",
1746                   "sfindp name view x y Uindex Vindex",
1747                   __FILE__,
1748                   sfindp,g);
1749
1750   theCommands.Add("setuperiodic",
1751                   "setuperiodic name ...",
1752                   __FILE__,
1753                   ssetperiodic,g);
1754
1755   theCommands.Add("setvperiodic",
1756                   "setvperiodic name ...",
1757                   __FILE__,
1758                   ssetperiodic,g);
1759
1760   theCommands.Add("setunotperiodic",
1761                   "setunotperiodic name ...",
1762                   __FILE__,
1763                   ssetperiodic,g);
1764
1765   theCommands.Add("setvnotperiodic",
1766                   "setvnotperiodic name ...",
1767                   __FILE__,
1768                   ssetperiodic,g);
1769
1770   theCommands.Add("exchuv",
1771                   "exchuv name ...",
1772                   __FILE__,
1773                   exchuv,g);
1774
1775   theCommands.Add("segsur",
1776                   "segsur name Ufirst Ulast Vfirst Vlast",
1777                   __FILE__,
1778                   segsur , g);
1779
1780   theCommands.Add("setuorigin",
1781                   "setuorigin name knotindex",
1782                   __FILE__,
1783                   setuvorigin , g);
1784
1785   theCommands.Add("setvorigin",
1786                   "setvorigin name knotindex",
1787                   __FILE__,
1788                   setuvorigin , g);
1789
1790   g = "GEOMETRY curves creation";
1791
1792
1793   theCommands.Add("uiso",
1794                   "uiso curvename surfacename u",
1795                   __FILE__,
1796                   iso,g);
1797
1798   theCommands.Add("viso",
1799                   "viso curvename surfacename v",
1800                   __FILE__,
1801                   iso,g);
1802
1803
1804   g = "GEOMETRY curves and surfaces analysis";
1805
1806   theCommands.Add("svalue",
1807                   "svalue surfname U V X Y Z [DUX DUY DUZ DVX DVY DVZ [D2UX D2UY D2UZ D2VX D2VY D2VZ D2UVX D2UVY D2UVZ]]",
1808                   __FILE__,
1809                   value,g);
1810
1811   theCommands.Add("parameters",
1812                   "parameters surf/curve X Y [Z] Tol U [V] : {X Y Z} point, {U V} output parameter(s)",
1813                   __FILE__,
1814                   parameters,g);
1815
1816   theCommands.Add("bounds",
1817                   "bounds S/C/C2d U1 U2 [V1 V2]",
1818                   __FILE__,
1819                   bounds,g);
1820
1821   theCommands.Add("surface_radius",
1822                   "surface_radius surface Uvalue <Real> Vvalue <Real> returns min max radius of curvature",
1823                   __FILE__,
1824                   surface_radius,g);
1825   theCommands.Add("compBsplSur","BsplSurf1 BSplSurf2",__FILE__,compBsplSur,g);
1826   
1827   
1828 }