0024708: Convertation of the generic classes to the non-generic. Part 2
[occt.git] / src / GeometryTest / GeometryTest_ConstraintCommands.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 // JPI : Commande smooth transferee dans GeomliteTest
18 // PMN : Ajout de la commande smooth
19 // JCT : Correction d'un trap dans la commande gcarc
20
21 #include <Standard_Stream.hxx>
22
23 #include <GeometryTest.hxx>
24 #include <DrawTrSurf.hxx>
25 #include <Draw.hxx>
26 #include <Draw_Appli.hxx>
27 #include <Draw_Interpretor.hxx>
28 #include <Geom2dGcc_Circ2d2TanRad.hxx>
29 #include <Geom2dGcc_Circ2d3Tan.hxx>
30 #include <Geom2dGcc_Circ2d2TanOn.hxx>
31 #include <Geom2dGcc_Circ2dTanOnRad.hxx>
32 #include <Geom2dGcc_Circ2dTanCen.hxx>
33 #include <Geom2dGcc_Lin2d2Tan.hxx>
34 #include <Geom2dGcc_Lin2dTanObl.hxx>
35 #include <Geom2dGcc.hxx>
36 #include <Geom2dGcc_QualifiedCurve.hxx>
37 #include <Geom2d_CartesianPoint.hxx>
38 #include <Geom2d_Circle.hxx>
39 #include <Geom2d_Line.hxx>
40 #include <Precision.hxx>
41 #include <GeomAPI_Interpolate.hxx>
42 #include <Draw_Marker3D.hxx>
43 #include <Geom2dAPI_Interpolate.hxx>
44 #include <Draw_Marker2D.hxx>
45 #include <TColgp_HArray1OfPnt.hxx>
46 #include <Geom_BSplineCurve.hxx>
47 #include <TColgp_HArray1OfPnt2d.hxx>
48 #include <Geom2d_BSplineCurve.hxx>
49 #include <DrawTrSurf_BSplineCurve.hxx>
50 #include <DrawTrSurf_BSplineCurve2d.hxx>
51 #include <TColgp_HArray1OfPnt.hxx>
52 #include <TColgp_Array1OfPnt.hxx>
53 #include <TColgp_Array1OfPnt2d.hxx>
54 #include <TColgp_HArray1OfVec.hxx>
55 #include <TColgp_Array1OfVec.hxx>
56 #include <TColStd_Array1OfReal.hxx>
57 #include <TColStd_HArray1OfReal.hxx>
58 #include <TColStd_HArray1OfBoolean.hxx>
59 #include <AppParCurves_MultiBSpCurve.hxx>
60 #include <AppDef_MultiLine.hxx>
61 #include <AppParCurves_HArray1OfConstraintCouple.hxx>
62 #include <AppParCurves_ConstraintCouple.hxx>
63 #include <GC_MakeSegment.hxx>
64 #include <GC_MakeArcOfCircle.hxx>
65
66 //#ifdef WNT
67 #include <stdio.h>
68 #ifdef WNT
69 Standard_IMPORT Draw_Viewer dout;
70 #endif
71 Standard_IMPORT Draw_Color DrawTrSurf_CurveColor(const Draw_Color);
72
73
74 static Standard_Integer solutions(Draw_Interpretor& di,
75                                   Geom2dGcc_Circ2d2TanRad& ct3, const char* name) 
76 {
77   char solname[200];
78
79   Draw_Color col = DrawTrSurf_CurveColor(Draw_Color(Draw_vert));
80   DrawTrSurf_CurveColor(col);
81
82   if (ct3.IsDone()) {
83     for (Standard_Integer i = 1 ; i <= ct3.NbSolutions() ; i++) {
84       Handle(Geom2d_Circle) C = new Geom2d_Circle(ct3.ThisSolution(i));
85       Sprintf(solname,"%s_%d",name,i);
86       char* temp = solname; // pour portage WNT
87       DrawTrSurf::Set(temp,C);
88       di << solname << " ";
89     }
90     return 0;
91   }
92   else {
93     di << "Circ2d2TanRad Not done";
94     return 1;
95   }
96 }
97
98 static Standard_Integer solutions(Draw_Interpretor& di,
99                                   Geom2dGcc_Circ2d3Tan& ct3, const char* name) 
100 {
101   char solname[200];
102
103   Draw_Color col = DrawTrSurf_CurveColor(Draw_Color(Draw_vert));
104   DrawTrSurf_CurveColor(col);
105
106   if (ct3.IsDone()) {
107     for (Standard_Integer i = 1 ; i <= ct3.NbSolutions() ; i++) {
108       Handle(Geom2d_Circle) C = new Geom2d_Circle(ct3.ThisSolution(i));
109       Sprintf(solname,"%s_%d",name,i);
110       char* temp = solname; // pour portage WNT
111       DrawTrSurf::Set(temp,C);
112       di << solname << " ";
113     }
114     return 0;
115   }
116   else {
117     di << "Circ2d3Tan Not done";
118     return 1;
119   }
120 }
121
122 //=======================================================================
123 //function : cirtang
124 //purpose  : 
125 //=======================================================================
126
127 static Standard_Integer cirtang (Draw_Interpretor& di,Standard_Integer n, const char** a)
128 {
129   if (n < 5) return 1;
130
131   Handle(Geom2d_Curve) C1 = DrawTrSurf::GetCurve2d(a[2]);
132   Handle(Geom2d_Curve) C2 = DrawTrSurf::GetCurve2d(a[3]);
133   Handle(Geom2d_Curve) C3 = DrawTrSurf::GetCurve2d(a[4]);
134   gp_Pnt2d P1,P2,P3;
135   Standard_Boolean ip1 = DrawTrSurf::GetPoint2d(a[2],P1);
136   Standard_Boolean ip2 = DrawTrSurf::GetPoint2d(a[3],P2);
137   Standard_Boolean ip3 = DrawTrSurf::GetPoint2d(a[4],P3);
138
139   Standard_Real tol = Precision::Confusion();
140   if (n > 5) tol = Draw::Atof(a[5]);
141
142
143   if (!C1.IsNull()) {
144     // C-...
145     if (!C2.IsNull()) {
146       // C-C-...
147       if (!C3.IsNull()) {
148         // C-C-C
149         Geom2dGcc_Circ2d3Tan ct3(Geom2dGcc::Unqualified(C1),
150           Geom2dGcc::Unqualified(C2),
151           Geom2dGcc::Unqualified(C3),
152           tol,0,0,0);
153         return solutions(di,ct3,a[1]);
154       }
155
156       else if (ip3) {
157         // C-C-P
158         Geom2dGcc_Circ2d3Tan ct3(Geom2dGcc::Unqualified(C1),
159           Geom2dGcc::Unqualified(C2),
160           new Geom2d_CartesianPoint(P3),
161           tol,0,0);
162         return solutions(di,ct3,a[1]);
163       }
164
165       else {
166         // C-C-R
167         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C1),
168           Geom2dGcc::Unqualified(C2),
169           Draw::Atof(a[4]),tol);
170         return solutions(di,ct3,a[1]);
171       }
172     }
173     else if (ip2) {
174       // C-P-..
175       if (!C3.IsNull()) {
176         // C-P-C
177         Geom2dGcc_Circ2d3Tan ct3(Geom2dGcc::Unqualified(C1),
178           Geom2dGcc::Unqualified(C3),
179           new Geom2d_CartesianPoint(P2),
180           tol,0,0);
181         return solutions(di,ct3,a[1]);
182       }
183
184       else if (ip3) {
185         // C-P-P
186         Geom2dGcc_Circ2d3Tan ct3(Geom2dGcc::Unqualified(C1),
187           new Geom2d_CartesianPoint(P2),
188           new Geom2d_CartesianPoint(P3),
189           tol,0);
190         return solutions(di,ct3,a[1]);
191       }
192
193       else {
194         // C-P-R
195         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C1),
196           new Geom2d_CartesianPoint(P2),
197           Draw::Atof(a[4]),tol);
198         return solutions(di,ct3,a[1]);
199       }
200     }
201
202     else {
203       // C-R-..
204       if (!C3.IsNull()) {
205         // C-R-C
206         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C1),
207           Geom2dGcc::Unqualified(C3),
208           Draw::Atof(a[3]),
209           tol);
210         return solutions(di,ct3,a[1]);
211       }
212
213       else if (ip3) {
214         // C-R-P
215         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C1),
216           new Geom2d_CartesianPoint(P3),
217           Draw::Atof(a[3]),
218           tol);
219         return solutions(di,ct3,a[1]);
220       }
221
222       else {
223         // C-R-R
224         di << "Curve, radius, radius ???"<<"\n";
225         return 1;
226       }
227     }
228   }
229
230   else if (ip1) {
231     // P-...
232     if (!C2.IsNull()) {
233       // P-C-...
234       if (!C3.IsNull()) {
235         // P-C-C
236         Geom2dGcc_Circ2d3Tan ct3(Geom2dGcc::Unqualified(C2),
237           Geom2dGcc::Unqualified(C3),
238           new Geom2d_CartesianPoint(P1),
239           tol,0,0);
240         return solutions(di,ct3,a[1]);
241       }
242
243       else if (ip3) {
244         // P-C-P
245         Geom2dGcc_Circ2d3Tan ct3(Geom2dGcc::Unqualified(C2),
246           new Geom2d_CartesianPoint(P1),
247           new Geom2d_CartesianPoint(P3),
248           tol,0);
249         return solutions(di,ct3,a[1]);
250       }
251
252       else {
253         // P-C-R
254         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C2),
255           new Geom2d_CartesianPoint(P1),
256           Draw::Atof(a[4]),tol);
257         return solutions(di,ct3,a[1]);
258       }
259     }
260     else if (ip2) {
261       // P-P-..
262       if (!C3.IsNull()) {
263         // P-P-C
264         Geom2dGcc_Circ2d3Tan ct3(Geom2dGcc::Unqualified(C3),
265           new Geom2d_CartesianPoint(P1),
266           new Geom2d_CartesianPoint(P2),
267           tol,0);
268         return solutions(di,ct3,a[1]);
269       }
270
271       else if (ip3) {
272         // P-P-P
273         Geom2dGcc_Circ2d3Tan ct3(new Geom2d_CartesianPoint(P1),
274           new Geom2d_CartesianPoint(P2),
275           new Geom2d_CartesianPoint(P3),
276           tol);
277         return solutions(di,ct3,a[1]);
278       }
279
280       else {
281         // P-P-R
282         Geom2dGcc_Circ2d2TanRad ct3(new Geom2d_CartesianPoint(P1),
283           new Geom2d_CartesianPoint(P2),
284           Draw::Atof(a[4]),tol);
285         return solutions(di,ct3,a[1]);
286       }
287     }
288
289     else {
290       // P-R-..
291       if (!C3.IsNull()) {
292         // P-R-C
293         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C3),
294           new Geom2d_CartesianPoint(P1),
295           Draw::Atof(a[3]),
296           tol);
297         return solutions(di,ct3,a[1]);
298       }
299
300       else if (ip3) {
301         // P-R-P
302         Geom2dGcc_Circ2d2TanRad ct3(new Geom2d_CartesianPoint(P1),
303           new Geom2d_CartesianPoint(P3),
304           Draw::Atof(a[3]),
305           tol);
306         return solutions(di,ct3,a[1]);
307       }
308
309       else {
310         // P-R-R
311         di << "Point, radius, radius ???"<<"\n";
312         return 1;
313       }
314     }
315   }
316
317   else {
318     // R-...
319     if (!C2.IsNull()) {
320       // R-C-...
321       if (!C3.IsNull()) {
322         // R-C-C
323         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C2),
324           Geom2dGcc::Unqualified(C3),
325           Draw::Atof(a[2]),
326           tol);
327         return solutions(di,ct3,a[1]);
328       }
329
330       else if (ip3) {
331         // R-C-P
332         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C2),
333           new Geom2d_CartesianPoint(P3),
334           Draw::Atof(a[2]),
335           tol);
336         return solutions(di,ct3,a[1]);
337       }
338
339       else {
340         // R-C-R
341         di << "Radius - Curve - Radius ??"<<"\n";
342         return 1;
343       }
344     }
345     else if (ip2) {
346       // R-P-..
347       if (!C3.IsNull()) {
348         // R-P-C
349         Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C3),
350           new Geom2d_CartesianPoint(P2),
351           Draw::Atof(a[2]),
352           tol);
353         return solutions(di,ct3,a[1]);
354       }
355
356       else if (ip3) 
357       {
358         // R-P-P
359         Geom2dGcc_Circ2d2TanRad ct3(new Geom2d_CartesianPoint(P2),
360           new Geom2d_CartesianPoint(P3),
361           Draw::Atof(a[2]),
362           tol);
363         return solutions(di,ct3,a[1]);
364       }      
365       else {
366         // R-P-R
367         di << "Radius - Point - Radius ??"<<"\n";
368         return 1;
369       }
370     }
371     else {
372       // R-R-..
373       di << "radius, radius ???"<<"\n";
374       return 1;
375     }
376   }
377 }
378
379
380 //=======================================================================
381 //function : lintang
382 //purpose  : 
383 //=======================================================================
384
385 static Standard_Integer lintang (Draw_Interpretor& di,Standard_Integer n, const char** a)
386 {
387   if (n < 4) return 1;
388
389   Handle(Geom2d_Curve) C1 = DrawTrSurf::GetCurve2d(a[2]);
390   Handle(Geom2d_Curve) C2 = DrawTrSurf::GetCurve2d(a[3]);
391
392   char solname[200];
393
394   if (C1.IsNull() || C2.IsNull())
395     return 1;
396
397   Draw_Color col = DrawTrSurf_CurveColor(Draw_Color(Draw_vert));
398
399   if (n >= 5) {
400     Handle(Geom2d_Line) L = Handle(Geom2d_Line)::DownCast(C2);
401     if (L.IsNull()) {
402       di << "Second argument must be a line";
403       return 1;
404     }
405     Standard_Real ang = Draw::Atof(a[4]) * (M_PI / 180.0);
406     Geom2dGcc_Lin2dTanObl ct3(Geom2dGcc::Unqualified(C1),
407       L->Lin2d(),
408       Precision::Angular(),
409       (C1->FirstParameter()+C1->LastParameter())/2.,
410       ang);
411     if (ct3.IsDone()) {
412       for (Standard_Integer i = 1 ; i <= ct3.NbSolutions() ; i++) {
413         Handle(Geom2d_Line) LS = new Geom2d_Line(ct3.ThisSolution(i));
414         Sprintf(solname,"%s_%d",a[1],i);
415         char* temp = solname; // pour portage WNT
416         DrawTrSurf::Set(temp,LS);
417         di << solname << " ";
418       }
419     }
420     else
421       di << "Lin2dTanObl Not done" << "\n";
422   }
423   else {
424     Geom2dGcc_Lin2d2Tan ct3(Geom2dGcc::Unqualified(C1),
425       Geom2dGcc::Unqualified(C2),
426       Precision::Angular(),
427       (C1->FirstParameter()+C1->LastParameter())/2.,
428       (C2->FirstParameter()+C2->LastParameter())/2.);
429     if (ct3.IsDone()) {
430       for (Standard_Integer i = 1 ; i <= ct3.NbSolutions() ; i++) {
431         Handle(Geom2d_Line) LS = new Geom2d_Line(ct3.ThisSolution(i));
432         Sprintf(solname,"%s_%d",a[1],i);
433         char* temp = solname; // pour portage WNT
434         DrawTrSurf::Set(temp,LS);
435         di << solname << " ";
436       }
437     }
438     else
439       di << "Lin2d2Tan Not done" << "\n";
440   }
441
442   DrawTrSurf_CurveColor(col);
443
444   return 0;
445 }
446
447 //==================================================================================
448 static Standard_Integer interpol (Draw_Interpretor& di,Standard_Integer n, const char** a)
449 //==================================================================================
450 {
451   if (n == 1) {
452     di <<"give a name to your curve !" << "\n";
453     return 0;
454   }
455   if (n == 2) {
456     Standard_Integer id,XX,YY,b, i, j;
457     di << "Pick points "<< "\n";
458     dout.Select(id, XX, YY, b);
459     Standard_Real zoom = dout.Zoom(id);
460     if (b != 1) return 0;
461     if (id < 0) return 0;
462     gp_Pnt P;
463     gp_Pnt2d P2d;
464     Standard_Boolean newcurve;
465
466     if (dout.Is3D(id)) {
467       Handle(Draw_Marker3D) mark;
468       Handle(TColgp_HArray1OfPnt) Points = new TColgp_HArray1OfPnt(1, 1);
469       P.SetCoord((Standard_Real)XX/zoom,(Standard_Real)YY/zoom, 0.0);
470       Points->SetValue(1 , P);
471       Handle(TColgp_HArray1OfPnt) ThePoints = new TColgp_HArray1OfPnt(1, 2);
472       ThePoints->SetValue(1 , P);
473       mark = new Draw_Marker3D(Points->Value(1), Draw_X, Draw_vert);
474       dout << mark;
475       dout.Flush();
476       Handle(Geom_BSplineCurve) C;
477       i = 1;
478
479       while (b != 3) {
480         dout.Select(id,XX,YY,b, Standard_False);
481         P.SetCoord((Standard_Real)XX/zoom,(Standard_Real)YY/zoom, 0.0);
482         ThePoints->SetValue(i+1, P);
483         newcurve = Standard_False;
484         if (!(ThePoints->Value(i)).IsEqual(ThePoints->Value(i+1), 1.e-06)) {
485           if (b == 1) { 
486             i++;
487             mark = new Draw_Marker3D(ThePoints->Value(i), Draw_X, Draw_vert);
488             dout << mark;
489             dout.Flush();
490             Points = 
491               new TColgp_HArray1OfPnt(ThePoints->Lower(),ThePoints->Upper());
492             Points->ChangeArray1() = ThePoints->Array1();
493             newcurve = Standard_True;
494           }
495           GeomAPI_Interpolate anInterpolator(ThePoints,
496             Standard_False,
497             1.0e-5);
498           anInterpolator.Perform() ;
499           if (anInterpolator.IsDone()) {
500             C = anInterpolator.Curve() ;
501             Handle(DrawTrSurf_BSplineCurve) 
502               DC = new DrawTrSurf_BSplineCurve(C);
503             DC->ClearPoles();
504             DC->ClearKnots();
505             Draw::Set(a[1], DC);
506             dout.RepaintView(id);
507           }
508           if (newcurve) {
509             ThePoints = new TColgp_HArray1OfPnt(1, i+1);
510             for (j = 1; j <= i; j++) ThePoints->SetValue(j, Points->Value(j));
511           }
512         }
513       }
514       GeomAPI_Interpolate anInterpolator(ThePoints,
515         Standard_False,
516         1.0e-5);
517       anInterpolator.Perform() ;
518       if (anInterpolator.IsDone()) {
519         C = anInterpolator.Curve() ;
520         DrawTrSurf::Set(a[1], C);
521         dout.RepaintView(id);
522       }      
523     }
524     else {
525       Handle(Draw_Marker2D) mark;
526       Handle(TColgp_HArray1OfPnt2d) Points = new TColgp_HArray1OfPnt2d(1, 1);
527       P2d.SetCoord((Standard_Real)XX/zoom,(Standard_Real)YY/zoom);
528       Points->SetValue(1 , P2d);
529       Handle(TColgp_HArray1OfPnt2d) ThePoints = new TColgp_HArray1OfPnt2d(1, 2);
530       ThePoints->SetValue(1, P2d);
531       mark = new Draw_Marker2D(P2d, Draw_X, Draw_vert);
532       dout << mark;
533       dout.Flush();
534       Handle(Geom2d_BSplineCurve) C;
535       i = 1;
536
537       while (b != 3) {
538         dout.Select(id,XX,YY,b, Standard_False);
539         P2d.SetCoord((Standard_Real)XX/zoom,(Standard_Real)YY/zoom);
540         ThePoints->SetValue(i+1, P2d);
541         newcurve = Standard_False;
542         if (!(ThePoints->Value(i)).IsEqual(ThePoints->Value(i+1), 1.e-06)) {
543           if (b == 1) { 
544             i++;
545             mark = new Draw_Marker2D(P2d, Draw_X, Draw_vert);
546             dout << mark;
547             dout.Flush();
548             Points = 
549               new TColgp_HArray1OfPnt2d(ThePoints->Lower(),ThePoints->Upper());
550             Points->ChangeArray1() = ThePoints->Array1();
551             newcurve = Standard_True;
552           }
553           Geom2dAPI_Interpolate    a2dInterpolator(ThePoints,
554             Standard_False,
555             1.0e-5) ;
556           a2dInterpolator.Perform() ;
557           if (a2dInterpolator.IsDone()) { 
558             C = a2dInterpolator.Curve() ;
559
560             Handle(DrawTrSurf_BSplineCurve2d) 
561               DC = new DrawTrSurf_BSplineCurve2d(C);
562             DC->ClearPoles();
563             DC->ClearKnots();
564             Draw::Set(a[1], DC);
565             dout.RepaintView(id);
566           }
567
568           if (newcurve) {
569             ThePoints = new TColgp_HArray1OfPnt2d(1, i+1);
570             for (j = 1; j <= i; j++) ThePoints->SetValue(j, Points->Value(j));
571           }
572         }
573       }
574       Geom2dAPI_Interpolate    a2dInterpolator(Points,
575         Standard_False,
576         1.0e-5) ;
577       a2dInterpolator.Perform() ;
578       if (a2dInterpolator.IsDone()) { 
579         C = a2dInterpolator.Curve() ;
580
581         DrawTrSurf::Set(a[1], C);
582         dout.RepaintView(id); 
583       }
584
585     }
586   }
587   else if (n == 3) {
588     // lecture du fichier.
589     // nbpoints, 2d ou 3d, puis valeurs.
590     const char* nomfic = a[2];
591     ifstream iFile(nomfic, ios::in);
592     if (!iFile) return 1;
593     Standard_Integer nbp, i;
594     Standard_Real x, y, z;
595     iFile >> nbp;
596     char dimen[3];
597     iFile >> dimen;
598     if (!strcmp(dimen,"3d")) {
599       Handle_TColgp_HArray1OfPnt Point =
600         new TColgp_HArray1OfPnt(1, nbp);
601       for (i = 1; i <= nbp; i++) {
602         iFile >> x >> y >> z;
603         Point->SetValue(i, gp_Pnt(x, y, z));
604       }
605       GeomAPI_Interpolate  anInterpolator(Point,
606         Standard_False,
607         1.0e-5) ;
608       anInterpolator.Perform() ;
609       if (anInterpolator.IsDone()) { 
610         Handle(Geom_BSplineCurve) C = 
611           anInterpolator.Curve();
612         DrawTrSurf::Set(a[1], C);
613       }
614     }
615     else if (!strcmp(dimen,"2d")) {
616       Handle(TColgp_HArray1OfPnt2d)  PointPtr = 
617         new TColgp_HArray1OfPnt2d(1, nbp);
618       for (i = 1; i <= nbp; i++) {
619         iFile >> x >> y;
620         PointPtr->SetValue(i, gp_Pnt2d(x, y));
621       }
622       Geom2dAPI_Interpolate   a2dInterpolator(PointPtr,
623         Standard_False,
624         1.0e-5);
625       a2dInterpolator.Perform() ;
626       if (a2dInterpolator.IsDone()) {
627         Handle(Geom2d_BSplineCurve) C = a2dInterpolator.Curve() ;
628         DrawTrSurf::Set(a[1], C);
629       }
630     }
631   }
632   return 0;
633 }
634
635 static Standard_Integer tanginterpol (Draw_Interpretor& di,
636                                       Standard_Integer n, 
637                                       const char** a)
638 {
639
640
641   if (n < 4)
642     return 1;
643
644   Standard_Integer 
645     ii,
646     jj,
647     //    num_knots,
648     //    degree,
649     num_tangents,
650     num_read,
651     num_start,
652     num_parameters ;
653
654
655   Standard_Real 
656     //    delta,
657     tolerance;
658   //    parameter ;
659
660   Standard_Boolean periodic_flag = Standard_False ;
661   gp_Pnt a_point ;
662   gp_Vec a_vector ;
663   tolerance = 1.0e-5 ;
664
665
666
667
668   Handle(Geom_BSplineCurve) NewCurvePtr ;
669
670
671
672
673   num_read = 2 ;
674   if (strcmp(a[num_read],"p") == 0) {
675     periodic_flag = Standard_True ;
676     num_read += 1 ;
677   }
678   num_parameters = Draw::Atoi(a[num_read]) ;
679
680   if (num_parameters < 2) {
681     num_parameters = 2 ;
682   }
683   if ( n <  num_parameters * 3 + num_read) {
684     return 1 ;
685   }
686   Handle_TColgp_HArray1OfPnt   PointsArrayPtr=
687     new TColgp_HArray1OfPnt(1,num_parameters) ;
688
689   num_tangents = ((n - num_read) / 3)  - num_parameters ;
690   num_tangents = Max (0,num_tangents) ; 
691   num_tangents = Min (num_parameters, num_tangents) ;
692   ii = 1 ;
693   num_start = num_read ;
694   num_read += 1 ;
695   while (num_read <= num_parameters * 3 + num_start ) {
696     for (jj = 1 ; jj <= 3 ; jj++) {
697       a_point.SetCoord(jj,Draw::Atof(a[num_read])) ;
698       num_read += 1 ;
699     }
700     PointsArrayPtr->SetValue(ii,a_point) ;
701     ii += 1 ;
702   }
703   GeomAPI_Interpolate anInterpolator(PointsArrayPtr,
704     periodic_flag,
705     tolerance) ; 
706
707   if (num_tangents > 0) {
708     TColgp_Array1OfVec TangentsArray(1,num_parameters) ;
709     Handle_TColStd_HArray1OfBoolean 
710       TangentFlagsPtr =
711       new TColStd_HArray1OfBoolean(1,num_parameters) ;
712
713     for (ii = 1 ; ii <= num_tangents ; ii++) {
714       TangentFlagsPtr->SetValue(ii,Standard_True) ;
715     }
716     for (ii = num_tangents + 1 ; ii <= num_parameters ; ii++) {
717       TangentFlagsPtr->SetValue(ii,Standard_False) ;
718     }
719     ii = 1 ;
720     while (ii <= num_tangents) {
721       for (jj = 1 ; jj <= 3 ; jj++) {
722         a_vector.SetCoord(jj,Draw::Atof(a[num_read])) ;
723         num_read += 1 ;
724       }
725       TangentsArray.SetValue(ii,a_vector) ;
726       ii += 1 ;
727     }
728
729
730     anInterpolator.Load(TangentsArray,
731       TangentFlagsPtr) ;
732   }
733   anInterpolator.Perform() ;
734   if (anInterpolator.IsDone()) {
735     NewCurvePtr =
736       anInterpolator.Curve() ;
737
738     DrawTrSurf::Set(a[1],
739       NewCurvePtr) ;
740     di << a[2] << " " ;
741
742   }
743   return 0 ;
744 }
745
746 //==================================================================================
747 static Standard_Integer gcarc (Draw_Interpretor& di,Standard_Integer n, const char** a)
748 //==================================================================================
749 {
750   if (n >= 5) {
751     gp_Pnt P1,P2,P3,P4;
752     if (!strcmp(a[2], "seg")) {
753       if (DrawTrSurf::GetPoint(a[3], P1)) {
754         if (DrawTrSurf::GetPoint(a[4], P2)) {
755           Handle(Geom_Curve) theline = GC_MakeSegment(P1,P2).Value();
756           DrawTrSurf::Set(a[1], theline);
757           return 1;
758         }
759       }
760     }
761     else if (!strcmp(a[2], "cir")) {
762       if (DrawTrSurf::GetPoint(a[3], P1)) {
763         if (DrawTrSurf::GetPoint(a[4], P2)) {
764           if (DrawTrSurf::GetPoint(a[5], P3)) {
765             //      if (DrawTrSurf::GetPoint(a[6], P4)) {
766             if (n>6) {
767               DrawTrSurf::GetPoint(a[6], P4);
768               gp_Vec V1 = gp_Vec(P2,P3);                                                    
769               Handle(Geom_Curve)thearc = GC_MakeArcOfCircle(P1,V1,P4).Value();
770               DrawTrSurf::Set(a[1], thearc);
771               return 1;
772             }
773             else {
774               Handle(Geom_Curve)thearc = GC_MakeArcOfCircle(P1,P2,P3).Value();
775               DrawTrSurf::Set(a[1], thearc);
776               return 1;
777             }
778           }
779         }
780       }
781     }
782   }
783   di <<"give a name for arc and the type seg or cir then" << "\n";
784   di <<"give passing points p1 p2 for seg    p1 p2 p3 or p1 p2 p3 p4 for cir (p2 p3 is a tgtvec)!" << "\n";
785   return 0;
786 }
787
788 //=======================================================================
789 //function : ConstraintCommands
790 //purpose  : 
791 //=======================================================================
792
793
794 void  GeometryTest::ConstraintCommands(Draw_Interpretor& theCommands)
795 {
796
797   static Standard_Boolean loaded = Standard_False;
798   if (loaded) return;
799   loaded = Standard_True;
800
801   DrawTrSurf::BasicCommands(theCommands);
802
803   const char* g;
804   // constrained constructs
805   g = "GEOMETRY Constraints";
806
807   theCommands.Add("cirtang",
808     "cirtang cname curve/point/radius curve/point/radius curve/point/radius",
809     __FILE__,
810     cirtang,g);
811
812   theCommands.Add("lintan",
813     "lintan lname curve1 curve2 [angle]",
814     __FILE__,
815     lintang,g);
816
817
818   theCommands.Add("interpol",
819     "interpol cname [fic]", 
820     __FILE__,
821     interpol, g);
822   theCommands.Add("tanginterpol",
823     "tanginterpol curve [p] num_points points [tangents] modifier  p = periodic",
824     __FILE__,
825     tanginterpol,g);
826
827   theCommands.Add("gcarc",
828     "gcarc name seg/cir p1 p2 p3 p4",
829     __FILE__,
830     gcarc,g);
831 }