97acc216d067368dece91cdadfaa99e3442876ae
[occt.git] / src / BRepTest / BRepTest_FeatureCommands.cxx
1 // Created on: 1995-06-16
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1995-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 #include <Draw_Interpretor.hxx>
18 #include <Draw_Appli.hxx>
19 #include <DrawTrSurf.hxx>
20
21 #include <TopTools_ListOfShape.hxx>
22 #include <TopTools_ListIteratorOfListOfShape.hxx>
23 #include <TopTools_MapOfShape.hxx>
24 #include <TopTools_MapIteratorOfMapOfShape.hxx>
25 #include <TopExp_Explorer.hxx>
26 #include <TopoDS_Face.hxx>
27 #include <TopoDS_Wire.hxx>
28 #include <TopoDS_Shell.hxx>
29 #include <TopoDS_Compound.hxx>
30 #include <TopoDS_Edge.hxx>
31 #include <TopoDS.hxx>
32
33 #include <Geom_RectangularTrimmedSurface.hxx>
34 #include <Geom_Plane.hxx>
35 #include <Geom_CylindricalSurface.hxx>
36 #include <gp_Lin.hxx>
37 #include <gp_Pln.hxx>
38 #include <gp_Cylinder.hxx>
39
40 //#include <BRepFeat_LocalOperation.hxx>
41 #include <BRepFeat_Builder.hxx>
42 #include <BRepFeat_MakeCylindricalHole.hxx>
43 #include <BRepFeat_SplitShape.hxx>
44 #include <BRepFeat_Gluer.hxx>
45
46 #include <BRepFeat.hxx>
47 #include <BRepFeat_MakePrism.hxx>
48 #include <BRepFeat_MakeRevol.hxx>
49 #include <BRepFeat_MakePipe.hxx>
50 #include <BRepFeat_MakeDPrism.hxx>
51 #include <BRepFeat_MakeLinearForm.hxx>
52 #include <BRepFeat_MakeRevolutionForm.hxx>
53
54 #include <LocOpe_FindEdges.hxx>
55 #include <LocOpe_FindEdgesInFace.hxx>
56
57 #include <BRepOffsetAPI_MakeOffsetShape.hxx>
58 #include <BRepOffsetAPI_MakeThickSolid.hxx>
59 #include <BRep_Tool.hxx>
60 #include <BRep_Builder.hxx>
61 #include <DBRep.hxx>
62 #include <DBRep_DrawableShape.hxx>
63 #include <BRepTest.hxx>
64
65 #include <BRepFilletAPI_MakeFillet.hxx>
66 #include <ChFi3d_FilletShape.hxx>
67
68 #include <Precision.hxx>
69
70 #ifdef _WIN32
71 //#define strcasecmp _stricmp Already defined
72 Standard_IMPORT Draw_Viewer dout;
73 #endif
74
75 static BRepFeat_MakeCylindricalHole theHole;
76 static Standard_Boolean WithControl = Standard_True;
77
78 Standard_Boolean DownCastingEnforcing = Standard_False;
79
80 static BRepFeat_MakePrism thePrism;
81 static BRepFeat_MakeDPrism theDPrism;
82 static BRepFeat_MakeRevol theRevol;
83 static BRepFeat_MakePipe  thePipe;
84 static BRepFeat_MakeLinearForm  theLF;
85 static BRepFeat_MakeRevolutionForm  theRF;
86
87 static Standard_Boolean dprdef = Standard_False;
88 static Standard_Boolean prdef = Standard_False;
89 static Standard_Boolean rvdef = Standard_False;
90 static Standard_Boolean pidef = Standard_False;
91 static Standard_Boolean lfdef = Standard_False;
92 static Standard_Boolean rfdef = Standard_False;
93
94 static Standard_Real t3d = 1.e-4;
95 static Standard_Real t2d = 1.e-5;
96 static Standard_Real ta  = 1.e-2;
97 static Standard_Real fl  = 1.e-3;
98 static Standard_Real tapp_angle = 1.e-2;
99 static GeomAbs_Shape blend_cont = GeomAbs_C1;
100 static BRepFilletAPI_MakeFillet* Rakk = 0;
101
102
103
104 static void Print(Draw_Interpretor& di,
105                   const BRepFeat_Status St)
106 {
107   di << "  Error Status : ";
108   switch (St) {
109   case BRepFeat_NoError:
110     di << "No error";
111     break;
112
113   case BRepFeat_InvalidPlacement:
114     di << "Invalid placement";
115     break;
116
117   case BRepFeat_HoleTooLong:
118     di << "Hole too long";
119     break;
120   }
121 }
122
123 static Standard_Integer Loc(Draw_Interpretor& theCommands,
124                             Standard_Integer narg, const char** a)
125 {
126   if (narg<6) return 1;
127   TopoDS_Shape S = DBRep::Get(a[2]);
128   TopoDS_Shape T = DBRep::Get(a[3]);
129
130   Standard_Boolean Fuse;
131   if (!strcasecmp("F",a[4])) {
132     Fuse = Standard_True;
133   }
134   else if (!strcasecmp("C",a[4])) {
135     Fuse = Standard_False;
136   }
137   else {
138     return 1;
139   }
140
141   TopTools_ListOfShape LF;
142   for (Standard_Integer i=0; i<= narg-6; i++) {
143     TopoDS_Shape aLocalShape(DBRep::Get(a[i+5],TopAbs_FACE));
144     LF.Append(aLocalShape);
145 //    LF.Append(TopoDS::Face(DBRep::Get(a[i+5],TopAbs_FACE)));
146   }
147
148   //BRepFeat_LocalOperation BLoc(S);
149   //BLoc.Perform(T,LF,Fuse);
150   //BLoc.BuildPartsOfTool();
151   TopTools_ListOfShape parts;
152   BRepFeat_Builder BLoc;
153   BLoc.Init(S,T);
154   BLoc.SetOperation(Fuse);
155   //BRepFeat_LocalOperation BLoc;
156   //BLoc.Init(S,T,Fuse);
157   BLoc.Perform();
158   BLoc.PartsOfTool(parts);
159
160 #if 0
161   char newname[1024];
162   strcpy(newname,a[1]);
163   char* p = newname;
164   while (*p != '\0') p++;
165   *p = '_';
166   p++;
167   TopTools_ListIteratorOfListOfShape its(parts);
168   dout.Clear();
169   i = 0;
170   for (; its.More(); its.Next()) {
171     i++;
172     Sprintf(p,"%d",i);
173     DBRep::Set(newname,its.Value());
174   }
175   if (i >= 2) {
176     dout.Flush();
177     Standard_Integer qq,ww,ee,button;
178     TopoDS_Shell S;
179     do {
180       TopoDS_Shape aLocalShape(DBRep::Get(".",TopAbs_SHELL));
181       S = TopoDS::Shell(aLocalShape);
182 //      S = TopoDS::Shell(DBRep::Get(".",TopAbs_SHELL));
183       Draw::LastPick(qq,ww,ee,button);
184       if (!S.IsNull()) {
185         
186         switch (button) {
187         case 1:
188           //BLoc.RemovePart(S);
189           break;
190         case 2:
191           BLoc.KeepPart(S);
192           break;
193         default:
194           {}
195         }
196       }
197       else {
198         button = 3;
199       }
200
201     } while (button != 3);
202   }
203 #endif
204   BLoc.PerformResult();
205   if (!BLoc.ErrorStatus()) {
206 //    dout.Clear();
207     DBRep::Set(a[1],BLoc.Shape());
208     dout.Flush();
209     return 0;
210   }
211   theCommands << "Local operation not done" ;
212   return 1;
213 }
214
215
216
217 static Standard_Integer HOLE1(Draw_Interpretor& theCommands,
218                               Standard_Integer narg, const char** a)
219 {
220   if (narg<10 || narg == 11) return 1;
221   TopoDS_Shape S = DBRep::Get(a[2]);
222
223   gp_Pnt Or(Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5]));
224   gp_Dir Di(Draw::Atof(a[6]),Draw::Atof(a[7]),Draw::Atof(a[8]));
225
226   Standard_Real Radius = Draw::Atof(a[9]);
227
228   theHole.Init(S,gp_Ax1(Or,Di));
229
230   if (narg <= 10) {
231     theHole.Perform(Radius);
232   }
233   else {
234     Standard_Real pfrom = Draw::Atof(a[10]);
235     Standard_Real pto   = Draw::Atof(a[11]);
236     theHole.Perform(Radius,pfrom,pto,WithControl);
237   }
238
239   theHole.Build();
240   if (!theHole.ErrorStatus()) {
241 //    dout.Clear();
242     DBRep::Set(a[1],theHole.Shape());
243     dout.Flush();
244     return 0;
245   }
246   theCommands << "Echec de MakeCylindricalHole";
247   Print(theCommands,theHole.Status());
248   return 1;
249 }
250
251 static Standard_Integer HOLE2(Draw_Interpretor& theCommands,
252                               Standard_Integer narg, const char** a)
253 {
254   if (narg<10) return 1;
255   TopoDS_Shape S = DBRep::Get(a[2]);
256
257   gp_Pnt Or(Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5]));
258   gp_Dir Di(Draw::Atof(a[6]),Draw::Atof(a[7]),Draw::Atof(a[8]));
259
260   Standard_Real Radius = Draw::Atof(a[9]);
261
262   theHole.Init(S,gp_Ax1(Or,Di));
263   theHole.PerformThruNext(Radius,WithControl);
264
265   theHole.Build();
266   if (!theHole.ErrorStatus()) {
267 //    dout.Clear();
268     DBRep::Set(a[1],theHole.Shape());
269     dout.Flush();
270     return 0;
271   }
272   theCommands << "Echec de MakeCylindricalHole";
273   Print(theCommands,theHole.Status());
274   return 1;
275 }
276
277 static Standard_Integer HOLE3(Draw_Interpretor& theCommands,
278                               Standard_Integer narg, const char** a)
279 {
280   if (narg<10) return 1;
281   TopoDS_Shape S = DBRep::Get(a[2]);
282
283   gp_Pnt Or(Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5]));
284   gp_Dir Di(Draw::Atof(a[6]),Draw::Atof(a[7]),Draw::Atof(a[8]));
285
286   Standard_Real Radius = Draw::Atof(a[9]);
287
288   theHole.Init(S,gp_Ax1(Or,Di));
289   theHole.PerformUntilEnd(Radius,WithControl);
290   theHole.Build();
291   if (!theHole.ErrorStatus()) {
292 //    dout.Clear();
293     DBRep::Set(a[1],theHole.Shape());
294     dout.Flush();
295     return 0;
296   }
297   theCommands << "Echec de MakeCylindricalHole";
298   Print(theCommands,theHole.Status());
299   return 1;
300 }
301
302
303 static Standard_Integer HOLE4(Draw_Interpretor& theCommands,
304                               Standard_Integer narg, const char** a)
305 {
306   if (narg<11) return 1;
307   TopoDS_Shape S = DBRep::Get(a[2]);
308
309   gp_Pnt Or(Draw::Atof(a[3]),Draw::Atof(a[4]),Draw::Atof(a[5]));
310   gp_Dir Di(Draw::Atof(a[6]),Draw::Atof(a[7]),Draw::Atof(a[8]));
311
312   Standard_Real Radius = Draw::Atof(a[9]);
313   Standard_Real Length = Draw::Atof(a[10]);
314
315   theHole.Init(S,gp_Ax1(Or,Di));
316   theHole.PerformBlind(Radius,Length,WithControl);
317   theHole.Build();
318   if (!theHole.ErrorStatus()) {
319 //    dout.Clear();
320     DBRep::Set(a[1],theHole.Shape());
321     dout.Flush();
322     return 0;
323   }
324   theCommands << "Echec de MakeCylindricalHole";
325   Print(theCommands,theHole.Status());
326   return 1;
327 }
328
329 static Standard_Integer CONTROL(Draw_Interpretor& theCommands,
330                                 Standard_Integer narg, const char** a)
331 {
332   if (narg >= 2) {
333     WithControl = strcmp("0",a[1]);
334   }
335   if (WithControl) {
336     theCommands << "Mode avec controle";
337   }
338   else {
339     theCommands << "Mode sans controle";
340   }
341   return 0;
342 }
343       
344
345 //=======================================================================
346 //function : PRW
347 //purpose  : 
348 //=======================================================================
349
350 static Standard_Integer PRW(Draw_Interpretor& theCommands,
351                             Standard_Integer narg, const char** a)
352 {
353   if (narg<9) return 1;
354   TopoDS_Shape S = DBRep::Get(a[3]);
355   BRepFeat_MakePrism thePFace;
356   gp_Vec V;
357   TopoDS_Shape FFrom,FUntil;
358   Standard_Integer borne;
359   Standard_Boolean fuse;
360   if (a[1][0] == 'f' || a[1][0] == 'F') {
361     fuse = Standard_True;
362   }
363   else if (a[1][0] == 'c' || a[1][0] == 'C') {
364     fuse = Standard_False;
365   }
366   else {
367     return 1;
368   }
369
370   if (a[4][0] == '.' || IsAlphabetic(a[4][0])) {
371     if (narg < 10) {
372       return 1;
373     }
374     if (a[5][0] == '.' || IsAlphabetic(a[5][0])) {
375       if (narg < 11) {
376         return 1;
377       }
378       V.SetCoord(Draw::Atof(a[6]),Draw::Atof(a[7]),Draw::Atof(a[8]));
379       FFrom   = DBRep::Get(a[4],TopAbs_SHAPE);
380       FUntil  = DBRep::Get(a[5],TopAbs_SHAPE);
381       borne = 9;
382     }
383     else {
384       V.SetCoord(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]));
385       FUntil  = DBRep::Get(a[4],TopAbs_SHAPE);
386       borne = 8;
387     }
388   }
389   else {
390     V.SetCoord(Draw::Atof(a[4]),Draw::Atof(a[5]),Draw::Atof(a[6]));
391     borne = 7;
392   }
393   Standard_Real Length = V.Magnitude();
394   if (Length < Precision::Confusion()) {
395     return 1;
396   }
397
398   TopoDS_Shape aLocalShape(DBRep::Get(a[borne],TopAbs_FACE));
399   TopoDS_Face F  = TopoDS::Face(aLocalShape);
400 //  TopoDS_Face F  = TopoDS::Face(DBRep::Get(a[borne],TopAbs_FACE));
401   BRepFeat_SplitShape Spls(F);
402   for (Standard_Integer i = borne+1; i<narg; i++) {
403     TopoDS_Wire wir;
404     if (a[i][0] !='-') {
405       aLocalShape = DBRep::Get(a[i],TopAbs_WIRE);
406       wir = TopoDS::Wire(aLocalShape);
407 //      wir = TopoDS::Wire(DBRep::Get(a[i],TopAbs_WIRE));
408     }
409     else {
410       if (a[i][1] == '\0')
411         return 1;
412       const char* Temp = a[i]+1;
413       aLocalShape = DBRep::Get(Temp,TopAbs_WIRE);
414       wir = TopoDS::Wire(aLocalShape);
415 //      wir = TopoDS::Wire(DBRep::Get(Temp,TopAbs_WIRE));
416       wir.Reverse();
417     }
418     Spls.Add(wir,F);
419   }
420   Spls.Build();
421
422   TopoDS_Shape ToPrism;
423   const TopTools_ListOfShape& lleft = Spls.DirectLeft();
424   if (lleft.Extent() == 1) {
425     thePFace.Init(S,lleft.First(),F,V,fuse,Standard_True);
426     ToPrism = lleft.First();
427   }
428   else {
429     BRep_Builder B;
430     TopoDS_Shell Sh;
431     B.MakeShell(Sh);
432     TopTools_ListIteratorOfListOfShape it;
433     for (it.Initialize(lleft);it.More();it.Next()) {
434       B.Add(Sh,TopoDS::Face(it.Value()));
435     }
436     Sh.Closed (BRep_Tool::IsClosed (Sh));
437     thePFace.Init(S,Sh,F,V,fuse,Standard_True);
438     ToPrism = Sh;
439   }
440
441   // Recherche des faces de glissement, si on n`a pas sketche sur une face
442   // du shape de depart
443
444 //  for (TopExp_Explorer exp(S,TopAbs_FACE);exp.More();exp.Next()) {
445   TopExp_Explorer exp(S,TopAbs_FACE) ;
446   for ( ;exp.More();exp.Next()) {
447     if (exp.Current().IsSame(F)) {
448       break;
449     }
450   }
451
452   if (!exp.More()) {
453     LocOpe_FindEdgesInFace FEIF;
454     for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
455       const TopoDS_Face& fac = TopoDS::Face(exp.Current());
456       Handle(Geom_Surface) Su = BRep_Tool::Surface(fac);
457       if (Su->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
458         Su = Handle(Geom_RectangularTrimmedSurface)::
459         DownCast(Su)->BasisSurface();
460       }
461       if (Su->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
462         gp_Pln pl = Handle(Geom_Plane)::DownCast(Su)->Pln();
463         if (pl.Contains(gp_Lin(pl.Location(),V),
464                         Precision::Confusion(),
465                         Precision::Angular())) {
466           FEIF.Set(ToPrism,fac);
467           for (FEIF.Init();FEIF.More();FEIF.Next()) {
468             thePFace.Add(FEIF.Edge(),fac);
469           }
470         }
471       }
472       else if (Su->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface)) {
473         gp_Cylinder cy = 
474           Handle(Geom_CylindricalSurface)::DownCast(Su)->Cylinder();
475         if (V.IsParallel(cy.Axis().Direction(),Precision::Angular())) {
476           FEIF.Set(ToPrism,fac);
477           for (FEIF.Init();FEIF.More();FEIF.Next()) {
478             thePFace.Add(FEIF.Edge(),fac);
479           }
480         }
481       }
482     }
483   }
484
485   if (borne == 7) {
486     thePFace.Perform(Length);
487   }
488   else if (borne == 8) {
489     thePFace.Perform(FUntil);
490   }
491   else if (borne == 9) {
492     if (!(FFrom.IsNull() || FUntil.IsNull())) {
493       thePFace.Perform(FFrom,FUntil);
494     }
495     else if (FFrom.IsNull()) {
496       if (!FUntil.IsNull()) {
497         thePFace.PerformFromEnd(FUntil);
498       }
499       else {
500         thePFace.PerformThruAll();
501       }
502     }
503     else {
504       // il faudrait inverser V et appeler PerfomFromEnd...
505       //cout << "Not Implemented" << endl;
506       theCommands << "Not Implemented" << "\n";
507     }
508   }
509   if (!thePFace.IsDone()) {
510     theCommands << "Local operation not done";
511     return 1;
512   }
513
514   DBRep::Set(a[2],thePFace);
515   dout.Flush();
516   return 0;
517 }
518
519
520 //=======================================================================
521 //function : PRF
522 //purpose  : 
523 //=======================================================================
524
525 static Standard_Integer PRF(Draw_Interpretor& theCommands,
526                             Standard_Integer narg, const char** a)
527 {
528   if (narg<8) return 1;
529   TopoDS_Shape S = DBRep::Get(a[3]);
530   BRepFeat_MakePrism thePFace;
531   Standard_Integer borne;
532   gp_Vec V;
533   TopoDS_Shape FFrom,FUntil;
534   Standard_Boolean fuse;
535   if (a[1][0] == 'f' || a[1][0] == 'F') {
536     fuse = Standard_True;
537   }
538   else if (a[1][0] == 'c' || a[1][0] == 'C') {
539     fuse = Standard_False;
540   }
541   else {
542     return 1;
543   }
544
545
546   if (a[4][0] == '.' || IsAlphabetic(a[4][0])) {
547     if (narg < 9) {
548       return 1;
549     }
550     if (a[5][0] == '.' || IsAlphabetic(a[5][0])) {
551       if (narg < 10) {
552         return 1;
553       }
554       borne = 9;
555       V.SetCoord(Draw::Atof(a[6]),Draw::Atof(a[7]),Draw::Atof(a[8]));
556       FFrom  = DBRep::Get(a[4],TopAbs_SHAPE);
557       FUntil  = DBRep::Get(a[5],TopAbs_SHAPE);
558     }
559     else {
560       borne = 8;
561       V.SetCoord(Draw::Atof(a[5]),Draw::Atof(a[6]),Draw::Atof(a[7]));
562       FUntil  = DBRep::Get(a[4],TopAbs_SHAPE);
563     }
564   }
565   else {
566     borne = 7;
567     V.SetCoord(Draw::Atof(a[4]),Draw::Atof(a[5]),Draw::Atof(a[6]));
568   }
569   Standard_Real Length = V.Magnitude();
570   if (Length < Precision::Confusion()) {
571     return 1;
572   }
573
574   TopoDS_Shape ToPrism;
575   if (narg == borne+1) {
576     TopoDS_Shape aLocalShape(DBRep::Get(a[borne],TopAbs_FACE));
577     TopoDS_Face F  = TopoDS::Face(aLocalShape);
578 //    TopoDS_Face F  = TopoDS::Face(DBRep::Get(a[borne],TopAbs_FACE));
579     thePFace.Init(S,F,F,V,fuse,Standard_True);
580     ToPrism = F;
581   }
582   else {
583     TopoDS_Shell She;
584     BRep_Builder B;
585     B.MakeShell(She);
586     for (Standard_Integer i=borne; i<narg; i++) {
587       TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_FACE));
588       TopoDS_Face F  = TopoDS::Face(aLocalShape);
589 //      TopoDS_Face F  = TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE));
590       if (!F.IsNull()) {
591         B.Add(She,F);
592       }
593     }
594     She.Closed (BRep_Tool::IsClosed (She));
595     thePFace.Init(S,She,TopoDS_Face(),V,fuse,Standard_False);
596     ToPrism = She;
597   }
598   
599   // Recherche des faces de glissement, on ne prisme pas une face
600   // du shape de depart
601
602 //  for (TopExp_Explorer exp(ToPrism,TopAbs_FACE);exp.More();exp.Next()) {
603   TopExp_Explorer exp(ToPrism,TopAbs_FACE) ;
604   for ( ;exp.More();exp.Next()) {
605 //    for (TopExp_Explorer exp2(S,TopAbs_FACE);exp2.More();exp2.Next()) {
606     TopExp_Explorer exp2(S,TopAbs_FACE) ;
607     for ( ;exp2.More();exp2.Next()) {
608       if (exp2.Current().IsSame(exp.Current())) {
609         break;
610       }
611     }
612     if (exp2.More()) {
613       break;
614     }
615   }
616
617   if (!exp.More()) {
618     LocOpe_FindEdgesInFace FEIF;
619     for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
620       const TopoDS_Face& fac = TopoDS::Face(exp.Current());
621       Handle(Geom_Surface) Su = BRep_Tool::Surface(fac);
622       if (Su->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
623         Su = Handle(Geom_RectangularTrimmedSurface)::
624         DownCast(Su)->BasisSurface();
625       }
626       if (Su->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
627         gp_Pln pl = Handle(Geom_Plane)::DownCast(Su)->Pln();
628         if (pl.Contains(gp_Lin(pl.Location(),V),
629                         Precision::Confusion(),
630                         Precision::Angular())) {
631           FEIF.Set(ToPrism,fac);
632           for (FEIF.Init();FEIF.More();FEIF.Next()) {
633             thePFace.Add(FEIF.Edge(),fac);
634           }
635         }
636       }
637       else if (Su->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface)) {
638         gp_Cylinder cy = 
639           Handle(Geom_CylindricalSurface)::DownCast(Su)->Cylinder();
640         if (V.IsParallel(cy.Axis().Direction(),Precision::Angular())) {
641           FEIF.Set(ToPrism,fac);
642           for (FEIF.Init();FEIF.More();FEIF.Next()) {
643             thePFace.Add(FEIF.Edge(),fac);
644           }
645         }
646       }
647     }
648   }
649
650   if (borne == 7) {
651     thePFace.Perform(Length);
652   }
653   else if (borne == 8) {
654     thePFace.Perform(FUntil);
655   }
656   else if (borne == 9) {
657     if (!(FFrom.IsNull() || FUntil.IsNull())) {
658       thePFace.Perform(FFrom,FUntil);
659     }
660     else if (FFrom.IsNull()) {
661       if (!FUntil.IsNull()) {
662         thePFace.PerformFromEnd(FUntil);
663       }
664       else {
665         thePFace.PerformThruAll();
666       }
667     }
668     else { //FUntil.IsNull()
669       // il faudrait inverser V et appeler PerfomFromEnd...
670       //cout << "Not Implemented" << endl;
671       theCommands << "Not Implemented" << "\n";
672     }
673   }
674   if (!thePFace.IsDone()) {
675     theCommands << "Local operation not done";
676     return 1;
677   }
678
679   DBRep::Set(a[2],thePFace);
680   dout.Flush();
681   return 0;
682 }
683
684
685
686 //=======================================================================
687 //function : SPLS
688 //purpose  : 
689 //=======================================================================
690
691 static Standard_Integer SPLS(Draw_Interpretor& ,
692                              Standard_Integer narg, const char** a)
693 {
694   Standard_Integer newnarg ;
695
696   if (narg<3) return 1;
697   TopoDS_Shape S = DBRep::Get(a[2]);
698   BRepFeat_SplitShape Spls(S);
699   Standard_Boolean pick = Standard_False;
700   TopoDS_Shape EF;
701   Standard_Real u,v;
702   Standard_Integer i = 3;
703
704   for ( newnarg=3; newnarg<narg; newnarg++) {
705     if (a[newnarg][0] == '@') {
706       break;
707     }
708   }
709
710   if (newnarg == 3 || 
711       (newnarg !=narg && ((narg-newnarg)<=2 || (narg-newnarg)%2 != 1))) {
712     return 1;
713   }
714
715   if (i<newnarg) {
716     pick = (a[i][0] == '.');
717     EF = DBRep::Get(a[i],TopAbs_FACE);
718     if (EF.IsNull()) return 1;
719   }
720   
721   while (i < newnarg) {
722     if (pick) {
723       DBRep_DrawableShape::LastPick(EF,u,v);
724     }
725     if (EF.ShapeType() == TopAbs_FACE) {
726       // face wire/edge ...
727       i++;
728       while (i < newnarg) {
729         TopoDS_Shape W;
730         Standard_Boolean rever = Standard_False;
731         if (a[i][0] == '-') {
732           if (a[i][1] == '\0')
733             return 1;
734           pick = (a[i][1] == '.');
735           const char* Temp = a[i]+1;
736           W = DBRep::Get(Temp,TopAbs_SHAPE,Standard_False);
737           rever = Standard_True;
738         }
739         else {
740           pick = (a[i][0] == '.');
741           W = DBRep::Get(a[i],TopAbs_SHAPE,Standard_False);
742         }
743         if (W.IsNull()) {
744           return 1; // on n`a rien recupere
745         }
746         TopAbs_ShapeEnum wtyp = W.ShapeType();
747         if (wtyp != TopAbs_WIRE && wtyp != TopAbs_EDGE && wtyp != TopAbs_COMPOUND && pick) {
748           Standard_Real u,v;
749           DBRep_DrawableShape::LastPick(W,u,v);
750           wtyp = W.ShapeType();
751         }
752         if (wtyp != TopAbs_WIRE && wtyp != TopAbs_EDGE && wtyp != TopAbs_COMPOUND) {
753           EF = DBRep::Get(a[i]);
754           break;
755         }
756         else {
757           if (rever) {
758             W.Reverse();
759           }
760           if (wtyp == TopAbs_WIRE) {
761             Spls.Add(TopoDS::Wire(W),TopoDS::Face(EF));
762           }
763           else if (wtyp == TopAbs_EDGE) {
764             Spls.Add(TopoDS::Edge(W),TopoDS::Face(EF));
765           }
766           else {
767             Spls.Add(TopoDS::Compound(W),TopoDS::Face(EF));
768           }
769         }
770         i++;
771       }
772     }
773     else
774       return 1;
775   }
776   
777   // ici, i vaut newnarg
778   for (i++; i<narg; i+=2) {
779     TopoDS_Shape Ew,Es;
780     TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_EDGE));
781     Es = TopoDS::Edge(aLocalShape);
782 //    Es = TopoDS::Edge(DBRep::Get(a[i],TopAbs_EDGE));
783     if (Es.IsNull()) {
784       return 1;
785     }
786     aLocalShape = DBRep::Get(a[i+1],TopAbs_EDGE);
787     Ew = TopoDS::Edge(aLocalShape);
788 //    Ew = TopoDS::Edge(DBRep::Get(a[i+1],TopAbs_EDGE));
789     if (Ew.IsNull()) {
790       return 1;
791     }
792     Spls.Add(TopoDS::Edge(Ew),TopoDS::Edge(Es));
793   }
794
795
796   DBRep::Set(a[1],Spls);
797   return 0;
798 }
799
800 //=======================================================================
801 //function : thickshell
802 //purpose  : 
803 //=======================================================================
804
805 Standard_Integer thickshell(Draw_Interpretor& ,
806                             Standard_Integer n, const char** a)
807 {
808
809   //OSD_Chronometer Clock;
810   
811   if ( n < 4) return 1;
812   TopoDS_Shape  S  = DBRep::Get(a[2]);
813   if (S.IsNull()) return 1;
814
815   Standard_Real    Of    = Draw::Atof(a[3]);
816
817   GeomAbs_JoinType JT= GeomAbs_Arc;
818   if (n > 4)
819     {
820       if (!strcmp(a[4],"i"))
821         JT = GeomAbs_Intersection;
822       if (!strcmp(a[4],"t"))
823         JT = GeomAbs_Tangent;
824     }
825   
826   Standard_Boolean Inter = Standard_False; //Standard_True;
827   Standard_Real    Tol = Precision::Confusion();
828   if (n > 5)
829     Tol = Draw::Atof(a[5]);
830
831   BRepOffset_MakeOffset B;
832   B.Initialize(S,Of,Tol,BRepOffset_Skin,Inter,0,JT, Standard_True);
833
834 //  Clock.Start();
835
836   B.MakeOffsetShape();
837   //B.MakeThickSolid ();
838
839 //  Clock.Show();
840
841   DBRep::Set(a[1],B.Shape());
842
843   return 0;
844 }
845
846 //=======================================================================
847 //function : offsetshape
848 //purpose  : 
849 //=======================================================================
850
851 Standard_Integer offsetshape(Draw_Interpretor& ,
852                              Standard_Integer n, const char** a)
853 {
854
855   //OSD_Chronometer Clock;
856   
857   if ( n < 4) return 1;
858   TopoDS_Shape  S  = DBRep::Get(a[2]);
859   if (S.IsNull()) return 1;
860
861   Standard_Real    Of    = Draw::Atof(a[3]);
862   Standard_Boolean Inter = (!strcmp(a[0],"offsetcompshape"));
863   GeomAbs_JoinType JT= GeomAbs_Arc;
864   if (!strcmp(a[0],"offsetinter")) {
865     JT    = GeomAbs_Intersection;
866     Inter = Standard_True;
867   }
868   
869   BRepOffset_MakeOffset B;
870   Standard_Integer      IB  = 4;
871   Standard_Real         Tol = Precision::Confusion();
872   if (n > 4) {
873     TopoDS_Shape  SF  = DBRep::Get(a[4],TopAbs_FACE);
874     if (SF.IsNull()) {
875       IB  = 5;
876       Tol = Draw::Atof(a[4]);
877     }
878   }
879   B.Initialize(S,Of,Tol,BRepOffset_Skin,Inter,0,JT);
880   //------------------------------------------
881   // recuperation et chargement des bouchons.
882   //----------------------------------------
883   Standard_Boolean YaBouchon = Standard_False;
884
885   for (Standard_Integer i = IB ; i < n; i++) {
886     TopoDS_Shape  SF  = DBRep::Get(a[i],TopAbs_FACE);
887     if (!SF.IsNull()) {
888       YaBouchon = Standard_True;
889       B.AddFace(TopoDS::Face(SF));
890     }
891   }
892
893 //  Clock.Start();
894
895   if (!YaBouchon)  B.MakeOffsetShape();
896   else             B.MakeThickSolid ();
897 //  Clock.Show();
898
899   DBRep::Set(a[1],B.Shape());
900
901   return 0;
902 }
903
904 static BRepOffset_MakeOffset TheOffset;
905 static Standard_Real         TheRadius;
906 static Standard_Boolean      theYaBouchon;
907 static Standard_Real         TheTolerance = Precision::Confusion();
908 static Standard_Boolean      TheInter     = Standard_False;
909 static GeomAbs_JoinType      TheJoin      = GeomAbs_Arc;
910
911 Standard_Integer offsetparameter(Draw_Interpretor& di,
912                                  Standard_Integer n, const char** a)
913 {
914   if ( n == 1 ) { 
915     //cout << " OffsetParameter Tol Inter(c/p) JoinType(a/i)" << endl;
916     //cout << " Current Values" << endl;
917     //cout << "   --> Tolerance :" << TheTolerance << endl;
918     //cout << "   --> TheInter  :";
919     di << " OffsetParameter Tol Inter(c/p) JoinType(a/i)" << "\n";
920     di << " Current Values" << "\n";
921     di << "   --> Tolerance :" << TheTolerance << "\n";
922     di << "   --> TheInter  :";
923     if ( TheInter) {
924       //cout << "Complet" ;
925       di << "Complet" ;
926     } else {
927       //cout << "Partial";
928       di << "Partial";
929     }
930     //cout << endl << "   --> TheJoin   :";
931     di << "\n" << "   --> TheJoin   :";
932     
933     switch (TheJoin) {
934     //case GeomAbs_Arc:          cout << " Arc";          break;
935     //case GeomAbs_Intersection: cout << " Intersection"; break;
936     case GeomAbs_Arc:          di << " Arc";          break;
937     case GeomAbs_Intersection: di << " Intersection"; break;
938     default:
939       break ;
940     }
941     //cout << endl;
942     di << "\n";
943
944     return 0;
945   }
946
947   if ( n < 4 ) return 1;
948   
949   TheTolerance = Draw::Atof(a[1]);
950   TheInter     = strcmp(a[2],"p");
951   
952   if      ( !strcmp(a[3],"a")) TheJoin = GeomAbs_Arc;
953   else if ( !strcmp(a[3],"i")) TheJoin = GeomAbs_Intersection;
954   else if ( !strcmp(a[3],"t")) TheJoin = GeomAbs_Tangent;
955     
956   return 0;    
957 }
958
959
960 //=======================================================================
961 //function : offsetinit
962 //purpose  : 
963 //=======================================================================
964
965 Standard_Integer offsetload(Draw_Interpretor& ,
966                             Standard_Integer n, const char** a)
967 {
968   if ( n < 2) return 1;
969   TopoDS_Shape  S  = DBRep::Get(a[1]);
970   if (S.IsNull()) return 1;
971
972   Standard_Real    Of    = Draw::Atof(a[2]);
973   TheRadius = Of;
974 //  Standard_Boolean Inter = Standard_True;
975   
976   TheOffset.Initialize(S,Of,TheTolerance,BRepOffset_Skin,TheInter,0,TheJoin);
977   //------------------------------------------
978   // recuperation et chargement des bouchons.
979   //----------------------------------------
980   for (Standard_Integer i = 3 ; i < n; i++) {
981     TopoDS_Shape  SF  = DBRep::Get(a[i],TopAbs_FACE);
982     if (!SF.IsNull()) {
983       TheOffset.AddFace(TopoDS::Face(SF));
984     }
985   }
986   if (n < 4)  theYaBouchon = Standard_False; //B.MakeOffsetShape();
987   else        theYaBouchon = Standard_True;  //B.MakeThickSolid ();
988
989   return 0;
990 }
991
992
993 //=======================================================================
994 //function : offsetonface
995 //purpose  : 
996 //=======================================================================
997
998 Standard_Integer offsetonface(Draw_Interpretor&, Standard_Integer n, const char** a)
999 {
1000   if ( n < 3) return 1;
1001
1002   for (Standard_Integer i = 1 ; i < n; i+=2) {
1003     TopoDS_Shape  SF  = DBRep::Get(a[i],TopAbs_FACE);
1004     if (!SF.IsNull()) {
1005       Standard_Real Of = Draw::Atof(a[i+1]);
1006       TheOffset.SetOffsetOnFace(TopoDS::Face(SF),Of);
1007     }
1008   }
1009   
1010   return 0;
1011 }
1012
1013 //=======================================================================
1014 //function : offsetperform
1015 //purpose  : 
1016 //=======================================================================
1017
1018 Standard_Integer offsetperform(Draw_Interpretor& theCommands,
1019                                Standard_Integer theNArg, const char** a)
1020   {
1021   if ( theNArg < 2) return 1;
1022
1023   if (theYaBouchon)
1024     TheOffset.MakeThickSolid ();
1025   else
1026     TheOffset.MakeOffsetShape();
1027
1028   if(TheOffset.IsDone())
1029     {
1030     DBRep::Set(a[1],TheOffset.Shape());
1031     }
1032   else
1033     {
1034     theCommands << "ERROR. offsetperform operation not done.";
1035     return 1;
1036     }
1037
1038   return 0;
1039   }
1040
1041
1042 //=======================================================================
1043 //function : Debou
1044 //purpose  : 
1045 //=======================================================================
1046
1047 static Standard_Integer Debou(Draw_Interpretor& theCommands,
1048                               Standard_Integer narg, const char** a)
1049 {
1050   Standard_Integer i ;
1051   Standard_Integer newnarg ;
1052
1053   if (narg<7) return 1;
1054   
1055   TopoDS_Shape S = DBRep::Get(a[2]);
1056
1057   Standard_Boolean Fuse;
1058   if (!strcasecmp("F",a[3])) {
1059     Fuse = Standard_True;
1060   }
1061   else if (!strcasecmp("C",a[3])) {
1062     Fuse = Standard_False;
1063   }
1064   else {
1065     return 1;
1066   }
1067
1068   for ( newnarg = 4; newnarg < narg; newnarg++) {
1069     if (a[newnarg][0] == '@') {
1070       break;
1071     }
1072   }
1073   if (newnarg >= narg-1 || newnarg == 4) {
1074     return 1;
1075   }
1076
1077
1078   TopTools_ListOfShape LF,LF2;
1079   for ( i=4; i<newnarg; i++) {
1080     TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_FACE));
1081     LF.Append(aLocalShape);
1082 //    LF.Append(TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE)));
1083   }
1084
1085   for (i=newnarg+1; i<narg; i++) {
1086     TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_FACE));
1087     LF2.Append(aLocalShape);
1088 //    LF2.Append(TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE)));
1089   }
1090
1091   //BRepFeat_LocalOperation BLoc(S);
1092   //BLoc.Perform(LF,LF2,Fuse);
1093   //BLoc.Build();
1094   BRepFeat_Builder BLoc;
1095   BLoc.Init(S, S);
1096   BLoc.Perform();
1097   BLoc.PerformResult();
1098   if (!BLoc.ErrorStatus()) {
1099 //    dout.Clear();
1100     DBRep::Set(a[1],BLoc.Shape());
1101     dout.Flush();
1102     return 0;
1103   }
1104   theCommands << "Local operation not done" ;
1105   return 1;
1106 }
1107
1108
1109 //=======================================================================
1110 //function : ROW
1111 //purpose  : 
1112 //=======================================================================
1113
1114 static Standard_Integer ROW(Draw_Interpretor& theCommands,
1115                             Standard_Integer narg, const char** a)
1116 {
1117   if (narg<13) return 1;
1118   TopoDS_Shape S = DBRep::Get(a[3]);
1119   BRepFeat_MakeRevol theRFace;
1120   gp_Dir D;
1121   gp_Pnt Or;
1122   Standard_Real Angle=0;
1123   TopoDS_Shape FFrom,FUntil;
1124   Standard_Integer i,borne;
1125   Standard_Boolean fuse;
1126
1127   if (a[1][0] == 'f' || a[1][0] == 'F') {
1128     fuse = Standard_True;
1129   }
1130   else if (a[1][0] == 'c' || a[1][0] == 'C') {
1131     fuse = Standard_False;
1132   }
1133   else {
1134     return 1;
1135   }
1136
1137   FFrom   = DBRep::Get(a[4],TopAbs_SHAPE);
1138   if (FFrom.IsNull()) {
1139     Angle = Draw::Atof(a[4]);
1140     Angle *=M_PI/180.;
1141     i = 5;
1142   }
1143   else {
1144     FUntil = DBRep::Get(a[5],TopAbs_SHAPE);
1145     if (FUntil.IsNull()) {
1146       i = 5;
1147       FUntil = FFrom;
1148       FFrom.Nullify();
1149       
1150     }
1151     else {
1152       if (narg < 14) {
1153         return 1;
1154       }
1155       i = 6;
1156     }
1157   }
1158   borne = i+6;
1159
1160   Or.SetCoord(Draw::Atof(a[i]),Draw::Atof(a[i+1]),Draw::Atof(a[i+2]));
1161   D.SetCoord(Draw::Atof(a[i+3]),Draw::Atof(a[i+4]),Draw::Atof(a[i+5]));
1162   gp_Ax1 theAxis(Or,D);
1163
1164   TopoDS_Shape aLocalShape(DBRep::Get(a[borne],TopAbs_FACE));
1165   TopoDS_Face F  = TopoDS::Face(aLocalShape);
1166 //  TopoDS_Face F  = TopoDS::Face(DBRep::Get(a[borne],TopAbs_FACE));
1167   BRepFeat_SplitShape Spls(F);
1168   for (i = borne+1; i<narg; i++) {
1169     TopoDS_Wire wir;
1170     if (a[i][0] !='-') {
1171       aLocalShape = DBRep::Get(a[i],TopAbs_WIRE);
1172       wir = TopoDS::Wire(aLocalShape);
1173 //      wir = TopoDS::Wire(DBRep::Get(a[i],TopAbs_WIRE));
1174     }
1175     else {
1176       if (a[i][1] == '\0')
1177         return 1;
1178       const char* Temp = a[i]+1;
1179       aLocalShape = DBRep::Get(Temp,TopAbs_WIRE);
1180       wir = TopoDS::Wire(aLocalShape);
1181 //      wir = TopoDS::Wire(DBRep::Get(Temp,TopAbs_WIRE));
1182       wir.Reverse();
1183     }
1184     Spls.Add(wir,F);
1185   }
1186   Spls.Build();
1187
1188   TopoDS_Shape ToRotate;
1189   const TopTools_ListOfShape& lleft = Spls.DirectLeft();
1190   if (lleft.Extent() == 1) {
1191     theRFace.Init(S,lleft.First(),F,theAxis,fuse,Standard_True);
1192     ToRotate = lleft.First();
1193   }
1194   else {
1195     BRep_Builder B;
1196     TopoDS_Shell Sh;
1197     B.MakeShell(Sh);
1198     TopTools_ListIteratorOfListOfShape it;
1199     for (it.Initialize(lleft);it.More();it.Next()) {
1200       B.Add(Sh,TopoDS::Face(it.Value()));
1201     }
1202     Sh.Closed (BRep_Tool::IsClosed (Sh));
1203     theRFace.Init(S,Sh,F,theAxis,fuse,Standard_True);
1204     ToRotate = Sh;
1205   }
1206
1207   // Recherche des faces de glissement
1208 //  for (TopExp_Explorer exp(S,TopAbs_FACE);exp.More();exp.Next()) {
1209   TopExp_Explorer exp(S,TopAbs_FACE) ;
1210   for ( ;exp.More();exp.Next()) {
1211     if (exp.Current().IsSame(F)) {
1212       break;
1213     }
1214   }
1215
1216   if (!exp.More()) {
1217     LocOpe_FindEdgesInFace FEIF;
1218     for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
1219       const TopoDS_Face& fac = TopoDS::Face(exp.Current());
1220       Handle(Geom_Surface) Su = BRep_Tool::Surface(fac);
1221       if (Su->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
1222         Su = Handle(Geom_RectangularTrimmedSurface)::
1223           DownCast(Su)->BasisSurface();
1224       }
1225       if (Su->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
1226         gp_Pln pl = Handle(Geom_Plane)::DownCast(Su)->Pln();
1227         if (pl.Axis().IsParallel(theAxis,Precision::Angular())) {
1228           FEIF.Set(ToRotate,fac);
1229           for (FEIF.Init();FEIF.More();FEIF.Next()) {
1230             theRFace.Add(FEIF.Edge(),fac);
1231           }
1232         }
1233       }
1234       else if (Su->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface)) {
1235         gp_Cylinder cy = 
1236           Handle(Geom_CylindricalSurface)::DownCast(Su)->Cylinder();
1237         if (cy.Axis().IsCoaxial(theAxis,
1238                                 Precision::Angular(),Precision::Confusion())) {
1239           FEIF.Set(ToRotate,fac);
1240           for (FEIF.Init();FEIF.More();FEIF.Next()) {
1241             theRFace.Add(FEIF.Edge(),fac);
1242           }
1243         }
1244       }
1245     }
1246   }
1247
1248   if (borne == 11) {
1249     if (FUntil.IsNull()) {
1250       theRFace.Perform(Angle);
1251     }
1252     else {
1253       theRFace.Perform(FUntil);
1254     }
1255   }
1256   else { // borne == 12
1257     theRFace.Perform(FFrom,FUntil);
1258   }
1259
1260   if (!theRFace.IsDone()) {
1261     theCommands << "Local operation not done";
1262     return 1;
1263   }
1264
1265   DBRep::Set(a[2],theRFace);
1266   dout.Flush();
1267   return 0;
1268 }
1269
1270
1271 //=======================================================================
1272 //function : ROF
1273 //purpose  : 
1274 //=======================================================================
1275
1276 static Standard_Integer ROF(Draw_Interpretor& theCommands,
1277                             Standard_Integer narg, const char** a)
1278 {
1279   if (narg<12) return 1;
1280   TopoDS_Shape S = DBRep::Get(a[3]);
1281   BRepFeat_MakeRevol theRFace;
1282   gp_Dir D;
1283   gp_Pnt Or;
1284   Standard_Real Angle=0;
1285   TopoDS_Shape FFrom,FUntil;
1286   Standard_Integer i,borne;
1287   Standard_Boolean fuse;
1288
1289   if (a[1][0] == 'f' || a[1][0] == 'F') {
1290     fuse = Standard_True;
1291   }
1292   else if (a[1][0] == 'c' || a[1][0] == 'C') {
1293     fuse = Standard_False;
1294   }
1295   else {
1296     return 1;
1297   }
1298
1299   FFrom   = DBRep::Get(a[4],TopAbs_SHAPE);
1300   if (FFrom.IsNull()) {
1301     Angle = Draw::Atof(a[4]);
1302     Angle *=M_PI/180.;
1303     i = 5;
1304   }
1305   else {
1306     FUntil = DBRep::Get(a[5],TopAbs_SHAPE);
1307     if (FUntil.IsNull()) {
1308       i = 5;
1309       FUntil = FFrom;
1310       FFrom.Nullify();
1311       
1312     }
1313     else {
1314       if (narg < 13) {
1315         return 1;
1316       }
1317       i = 6;
1318     }
1319   }
1320
1321   borne = i+6;
1322   Or.SetCoord(Draw::Atof(a[i]),Draw::Atof(a[i+1]),Draw::Atof(a[i+2]));
1323   D.SetCoord(Draw::Atof(a[i+3]),Draw::Atof(a[i+4]),Draw::Atof(a[i+5]));
1324   gp_Ax1 theAxis(Or,D);
1325
1326   TopoDS_Shape ToRotate;
1327   if (narg == borne+1) {
1328     TopoDS_Shape aLocalShape(DBRep::Get(a[borne],TopAbs_FACE));
1329     TopoDS_Face F  = TopoDS::Face(aLocalShape);
1330 //    TopoDS_Face F  = TopoDS::Face(DBRep::Get(a[borne],TopAbs_FACE));
1331     theRFace.Init(S,F,F,theAxis,fuse,Standard_True);
1332     ToRotate = F;
1333   }
1334   else {
1335     TopoDS_Shell She;
1336     BRep_Builder B;
1337     B.MakeShell(She);
1338     
1339     for (i=borne; i<narg; i++) {
1340       TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_FACE));
1341       TopoDS_Face F  = TopoDS::Face(aLocalShape);
1342 //      TopoDS_Face F  = TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE));
1343       if (!F.IsNull()) {
1344         B.Add(She,F);
1345       }
1346     }
1347     She.Closed (BRep_Tool::IsClosed (She));
1348     theRFace.Init(S,She,TopoDS_Face(),theAxis,fuse,Standard_False);
1349     ToRotate = She;
1350   }
1351
1352 //  for (TopExp_Explorer exp(ToRotate,TopAbs_FACE);exp.More();exp.Next()) {
1353   TopExp_Explorer exp(ToRotate,TopAbs_FACE) ;
1354   for ( ;exp.More();exp.Next()) {
1355 //    for (TopExp_Explorer exp2(S,TopAbs_FACE);exp2.More();exp2.Next()) {
1356     TopExp_Explorer exp2(S,TopAbs_FACE) ;
1357     for ( ;exp2.More();exp2.Next()) {
1358       if (exp2.Current().IsSame(exp.Current())) {
1359         break;
1360       }
1361     }
1362     if (exp2.More()) {
1363       break;
1364     }
1365   }
1366
1367   if (!exp.More()) {
1368     LocOpe_FindEdgesInFace FEIF;
1369     for (exp.Init(S,TopAbs_FACE);exp.More();exp.Next()) {
1370       const TopoDS_Face& fac = TopoDS::Face(exp.Current());
1371       Handle(Geom_Surface) Su = BRep_Tool::Surface(fac);
1372       if (Su->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
1373         Su = Handle(Geom_RectangularTrimmedSurface)::
1374           DownCast(Su)->BasisSurface();
1375       }
1376       if (Su->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
1377         gp_Pln pl = Handle(Geom_Plane)::DownCast(Su)->Pln();
1378         if (pl.Axis().IsParallel(theAxis,Precision::Angular())) {
1379           FEIF.Set(ToRotate,fac);
1380           for (FEIF.Init();FEIF.More();FEIF.Next()) {
1381             theRFace.Add(FEIF.Edge(),fac);
1382           }
1383         }
1384       }
1385       else if (Su->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface)) {
1386         gp_Cylinder cy = 
1387           Handle(Geom_CylindricalSurface)::DownCast(Su)->Cylinder();
1388         if (cy.Axis().IsCoaxial(theAxis,
1389                                 Precision::Angular(),Precision::Confusion())) {
1390           FEIF.Set(ToRotate,fac);
1391           for (FEIF.Init();FEIF.More();FEIF.Next()) {
1392             theRFace.Add(FEIF.Edge(),fac);
1393           }
1394         }
1395       }
1396     }
1397   }
1398
1399   if (borne == 11) {
1400     if (FUntil.IsNull()) {
1401       theRFace.Perform(Angle);
1402     }
1403     else {
1404       theRFace.Perform(FUntil);
1405     }
1406   }
1407   else { // borne == 12
1408     theRFace.Perform(FFrom,FUntil);
1409   }
1410
1411   if (!theRFace.IsDone()) {
1412     theCommands << "Local operation not done";
1413     return 1;
1414   }
1415
1416   DBRep::Set(a[2],theRFace);
1417   dout.Flush();
1418   return 0;
1419 }
1420
1421
1422 //=======================================================================
1423 //function : GLU
1424 //purpose  : Commande glue
1425 //=======================================================================
1426
1427 static Standard_Integer GLU(Draw_Interpretor& ,
1428                             Standard_Integer narg, const char** a)
1429 {
1430   if (narg<6 || narg%2 != 0) return 1;
1431   TopoDS_Shape Sne = DBRep::Get(a[2]);
1432   TopoDS_Shape Sba = DBRep::Get(a[3]);
1433   
1434   Standard_Boolean pick;
1435   
1436   BRepFeat_Gluer theGl(Sne,Sba);
1437   TopoDS_Shape Fne,Fba;
1438   
1439   LocOpe_FindEdges fined;
1440
1441   Standard_Integer i = 4;
1442   Standard_Boolean first = Standard_True;
1443   while (i<narg) {
1444     pick = (a[i][0] == '.');
1445     Fne = DBRep::Get(a[i]);
1446     if (Fne.IsNull()) {
1447       return 1;
1448     }
1449     TopAbs_ShapeEnum sht = Fne.ShapeType();
1450     if (pick && sht != TopAbs_FACE && sht != TopAbs_EDGE) {
1451       Standard_Real u,v;
1452       DBRep_DrawableShape::LastPick(Fne,u,v);
1453       sht = Fne.ShapeType();
1454     }
1455     if (first && sht != TopAbs_FACE) {
1456       return 1;
1457     }
1458     first = Standard_False;
1459     pick = (a[i+1][0] == '.');
1460     Fba = DBRep::Get(a[i+1]);
1461     if (Fba.IsNull()) {
1462       return 1;
1463     }
1464     if (pick && Fba.ShapeType() != sht) {
1465       Standard_Real u,v;
1466       DBRep_DrawableShape::LastPick(Fba,u,v);
1467     }
1468     if (Fba.ShapeType() != sht) {
1469       return 1;
1470     }
1471     if (sht == TopAbs_FACE) {
1472       const TopoDS_Face& f1 = TopoDS::Face(Fne);
1473       const TopoDS_Face& f2 = TopoDS::Face(Fba);
1474       theGl.Bind(f1,f2);
1475       fined.Set(Fne,Fba);
1476       for (fined.InitIterator(); fined.More(); fined.Next()) {
1477         theGl.Bind(fined.EdgeFrom(),fined.EdgeTo());
1478       }
1479     }
1480     else {
1481       theGl.Bind(TopoDS::Edge(Fne),TopoDS::Edge(Fba));
1482     }
1483     i +=2;
1484   }
1485   
1486   DBRep::Set(a[1],theGl);
1487   dout.Flush();
1488   return 0;
1489 }
1490
1491 static Standard_Integer DEFIN(Draw_Interpretor& theCommands,
1492                               Standard_Integer narg, const char** a)
1493 {
1494
1495   if (strcasecmp(a[0],"FEATPRISM") &&
1496       strcasecmp(a[0],"FEATDPRISM") &&
1497       strcasecmp(a[0],"FEATREVOL") &&
1498       strcasecmp(a[0],"FEATPIPE") &&
1499       strcasecmp(a[0],"FEATLF")  &&
1500       strcasecmp(a[0],"FEATRF")) {
1501     return 1;
1502   }
1503
1504   if ((!strcasecmp(a[0],"FEATPRISM") && narg !=9) ||
1505       (!strcasecmp(a[0],"FEATREVOL") && narg != 12) ||
1506       (!strcasecmp(a[0],"FEATDPRISM") && narg != 7) ||
1507       (!strcasecmp(a[0],"FEATPIPE") && narg != 7) ||
1508       (!strcasecmp(a[0],"FEATLF") && narg != 12) ||
1509       (!strcasecmp(a[0],"FEATRF") && narg != 14)) {
1510     theCommands << "invalid number of arguments";
1511     return 1;
1512   }
1513
1514   TopoDS_Shape Sbase = DBRep::Get(a[1]);
1515   if (Sbase.IsNull()) {
1516     theCommands << "null basis shape";
1517     return 1;
1518   }
1519   Standard_Integer Ifuse  = Draw::Atoi(a[narg-2]);
1520   Standard_Integer Imodif = Draw::Atoi(a[narg-1]);
1521   
1522   Standard_Integer Fuse = Ifuse;
1523   Standard_Boolean Modify = (Imodif!=0);
1524
1525   TopoDS_Shape Pbase;
1526   TopoDS_Face Skface;
1527   TopoDS_Wire W;
1528
1529   Handle(Geom_Plane) P;
1530
1531   BRepFeat_StatusError se;
1532
1533   if (strcasecmp(a[0],"FEATLF") && strcasecmp(a[0],"FEATRF")) {
1534     Pbase = DBRep::Get(a[2]);
1535     if (Pbase.IsNull()) {
1536       theCommands << "null shape to transform";
1537       return 1;
1538     }
1539     TopoDS_Shape aLocalShape(DBRep::Get(a[3],TopAbs_FACE));
1540     Skface = TopoDS::Face(aLocalShape);
1541 //    Skface = TopoDS::Face(DBRep::Get(a[3],TopAbs_FACE));
1542     if (Skface.IsNull()) {
1543       theCommands << "null face of Sketch";
1544       return 1;
1545     }
1546   }
1547   else {
1548     TopoDS_Shape aLocalShape(DBRep::Get(a[2], TopAbs_WIRE));
1549     W = TopoDS::Wire(aLocalShape);
1550 //    W = TopoDS::Wire(DBRep::Get(a[2], TopAbs_WIRE));
1551     if(W.IsNull()) {
1552       theCommands << "null profile for rib or slot";
1553       return 1;
1554     }
1555     Handle(Geom_Surface) s = DrawTrSurf::GetSurface(a[3]);
1556     P = Handle(Geom_Plane)::DownCast(s);
1557     if(P.IsNull()) {
1558       theCommands << "null plane to transform";
1559       return 1;
1560     }
1561   }
1562   if (narg == 9 || narg == 12 || narg == 14) {
1563 //    Standard_Real X,Y,Z,X1,Y1,Z1;
1564     Standard_Real X,Y,Z;
1565     X = Draw::Atof(a[4]);
1566     Y = Draw::Atof(a[5]);
1567     Z = Draw::Atof(a[6]);
1568     
1569     if (narg == 9) { // prism
1570       prdef = Standard_True;      
1571       thePrism.Init(Sbase,Pbase,Skface,gp_Dir(X,Y,Z),Fuse,Modify);
1572     }
1573     else if(narg == 14) {
1574       rfdef = Standard_True;
1575       gp_Pnt Or(X, Y, Z);
1576       X = Draw::Atof(a[7]);
1577       Y = Draw::Atof(a[8]);
1578       Z = Draw::Atof(a[9]);
1579       Standard_Real H1 = Draw::Atof(a[10]);
1580       Standard_Real H2 = Draw::Atof(a[11]);
1581       gp_Ax1 ax1(Or, gp_Dir(X, Y, Z));
1582       theRF.Init(Sbase, W, P, ax1, H1, H2, Fuse, Modify);
1583       if (!theRF.IsDone()) {
1584         se = theRF.CurrentStatusError();
1585         //BRepFeat::Print(se,cout) << endl;
1586         Standard_SStream aSStream;
1587         BRepFeat::Print(se,aSStream);
1588         theCommands << aSStream << "\n";
1589         return 1;
1590       }
1591     }
1592     else if(narg == 12 && strcasecmp(a[0],"FEATLF")) {
1593       rvdef = Standard_True;
1594       gp_Pnt Or(X,Y,Z);
1595       X = Draw::Atof(a[7]);
1596       Y = Draw::Atof(a[8]);
1597       Z = Draw::Atof(a[9]);
1598       theRevol.Init(Sbase,Pbase,Skface,gp_Ax1(Or,gp_Dir(X,Y,Z)),
1599                     Fuse,Modify);
1600     }
1601     else {
1602       lfdef = Standard_True;
1603       gp_Vec Direct(X,Y,Z);
1604       X = Draw::Atof(a[7]);
1605       Y = Draw::Atof(a[8]);
1606       Z = Draw::Atof(a[9]);
1607       theLF.Init(Sbase, W, P, Direct, gp_Vec(X,Y,Z), Fuse,Modify);
1608       if (!theLF.IsDone()) {
1609         se = theLF.CurrentStatusError();
1610         //BRepFeat::Print(se,cout) << endl;
1611         Standard_SStream aSStream;
1612         BRepFeat::Print(se,aSStream);
1613         theCommands << aSStream << "\n";
1614         return 1;
1615       }
1616     }
1617   }
1618   else if (narg == 7) {
1619     if (!strcasecmp(a[0],"FEATDPRISM")) {
1620       if (Pbase.ShapeType() != TopAbs_FACE) {
1621         theCommands << "Invalid DPrism base";
1622         return 1;
1623       }
1624       Standard_Real Angle = Draw::Atof(a[4])*M_PI/360; 
1625       dprdef = Standard_True;
1626       theDPrism.Init(Sbase,TopoDS::Face(Pbase),Skface,Angle,Fuse,Modify);
1627     }
1628     else { // FEATPIPE
1629       TopoDS_Shape aLocalShape(DBRep::Get(a[4],TopAbs_WIRE));
1630       TopoDS_Wire Spine = TopoDS::Wire(aLocalShape);
1631 //      TopoDS_Wire Spine = TopoDS::Wire(DBRep::Get(a[4],TopAbs_WIRE));
1632       if (Spine.IsNull()) {
1633         TopoDS_Shape Edspine =DBRep::Get(a[4],TopAbs_EDGE);
1634         if (Edspine.IsNull()) {
1635           theCommands << "null spine";
1636           return 1;
1637         }
1638         BRep_Builder B;
1639         B.MakeWire(Spine);
1640         B.Add(Spine,Edspine);
1641       }
1642       pidef = Standard_True;
1643       thePipe.Init(Sbase,Pbase,Skface,Spine,Fuse,Modify);
1644     }
1645   }
1646   return 0;
1647 }
1648
1649
1650
1651 static Standard_Integer ADD(Draw_Interpretor& ,
1652                             Standard_Integer narg, const char** a)
1653 {
1654   Standard_Integer i ;
1655   if (narg < 4 || narg%2 != 0) {
1656     return 1;
1657   }
1658   if (!strcasecmp("PRISM",a[1])) {
1659     if (!prdef) {
1660       return 1;
1661     }
1662     for ( i=2; i<narg; i+=2) {
1663       TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_EDGE));
1664       TopoDS_Edge edg = TopoDS::Edge(aLocalShape);
1665 //      TopoDS_Edge edg = TopoDS::Edge(DBRep::Get(a[i],TopAbs_EDGE));
1666       if (edg.IsNull()) {
1667         return 1;
1668       }
1669       aLocalShape = DBRep::Get(a[i+1],TopAbs_FACE);
1670       TopoDS_Face fac = TopoDS::Face(aLocalShape);
1671 //      TopoDS_Face fac = TopoDS::Face(DBRep::Get(a[i+1],TopAbs_FACE));
1672       if (fac.IsNull()) {
1673         return 1;
1674       }
1675       thePrism.Add(edg,fac);
1676     }
1677   }
1678   else if (!strcasecmp("REVOL",a[1])) {
1679     if (!rvdef) {
1680       return 1;
1681     }
1682     for ( i=2; i<narg; i+=2) {
1683       TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_EDGE));
1684       TopoDS_Edge edg = TopoDS::Edge(aLocalShape);
1685 //      TopoDS_Edge edg = TopoDS::Edge(DBRep::Get(a[i],TopAbs_EDGE));
1686       if (edg.IsNull()) {
1687         return 1;
1688       }
1689       aLocalShape = DBRep::Get(a[i+1],TopAbs_FACE);
1690       TopoDS_Face fac = TopoDS::Face(aLocalShape);
1691 //      TopoDS_Face fac = TopoDS::Face(DBRep::Get(a[i+1],TopAbs_FACE));
1692       if (fac.IsNull()) {
1693         return 1;
1694       }
1695       theRevol.Add(edg,fac);
1696     }
1697   }
1698   else if (!strcasecmp("PIPE",a[1])) {
1699     if (!pidef) {
1700       return 1;
1701     }
1702     for ( i=2; i<narg; i+=2) {
1703       TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_EDGE));
1704       TopoDS_Edge edg = TopoDS::Edge(aLocalShape);
1705 //      TopoDS_Edge edg = TopoDS::Edge(DBRep::Get(a[i],TopAbs_EDGE));
1706       if (edg.IsNull()) {
1707         return 1;
1708       }
1709       aLocalShape = DBRep::Get(a[i+1],TopAbs_FACE);
1710       TopoDS_Face fac = TopoDS::Face(aLocalShape);
1711 //      TopoDS_Face fac = TopoDS::Face(DBRep::Get(a[i+1],TopAbs_FACE));
1712       if (fac.IsNull()) {
1713         return 1;
1714       }
1715       thePipe.Add(edg,fac);
1716     }
1717   }
1718   else {
1719     return 1;
1720   }
1721   return 0;
1722 }
1723
1724
1725
1726 static Standard_Integer PERF(Draw_Interpretor& theCommands,
1727                             Standard_Integer narg, const char** a)
1728 {
1729   if (narg < 3) {
1730     return 1;
1731   }
1732   if (strcasecmp(a[0],"FEATPERFORM") &&
1733       strcasecmp(a[0],"FEATPERFORMVAL")) {
1734     return 1;
1735   }
1736
1737   Standard_Integer Kas;
1738   if (!strcasecmp("PRISM",a[1])) {
1739     Kas = 1;
1740     if (!prdef) {
1741       theCommands << "prism not defined";
1742       return 1;
1743     }
1744   }
1745   else if (!strcasecmp("REVOL",a[1])) {
1746     Kas = 2;
1747     if (!rvdef) {
1748       theCommands << "revol not defined";
1749       return 1;
1750     }
1751   }
1752   else if (!strcasecmp("PIPE",a[1])) {
1753     Kas = 3;
1754     if (!pidef) {
1755       theCommands << "pipe not defined";
1756       return 1;
1757     }
1758     if (!strcasecmp(a[0],"FEATPERFORMVAL")) {
1759       theCommands << "invalid command for pipe";
1760       return 1;
1761     }
1762   }
1763   else if (!strcasecmp("DPRISM",a[1])) {
1764     Kas = 4;
1765     if (!dprdef) {
1766       theCommands << "dprism not defined";
1767       return 1;
1768     }
1769   }
1770   else if (!strcasecmp("LF",a[1])) {
1771     Kas = 5;
1772     if (!lfdef) {
1773       theCommands << "lf not defined";
1774       return 1;
1775     }
1776     if (!strcasecmp(a[0],"FEATPERFORMVAL")) {
1777       theCommands << "invalid command for lf";
1778       return 1;
1779     }
1780   }
1781   else if (!strcasecmp("RF",a[1])) {
1782     Kas = 6;
1783     if (!rfdef) {
1784       theCommands << "rf not defined";
1785       return 1;
1786     }
1787     if (!strcasecmp(a[0],"FEATPERFORMVAL")) {
1788       theCommands << "invalid command for rf";
1789       return 1;
1790     }
1791   }
1792   else {
1793     theCommands << "unknown argument : " << a[1];
1794     return 1;
1795   }
1796
1797   if (!strcasecmp(a[0],"FEATPERFORMVAL")) {
1798     if (narg !=4 && narg != 5) {
1799       theCommands << "invalid number of arguments";
1800       return 1;
1801     }
1802     if (narg == 4) {
1803       Standard_Real Val = Draw::Atof(a[3]);
1804       if (Kas == 1) {
1805         thePrism.Perform(Val);
1806       }
1807       else if (Kas == 2) {
1808         Val *=(M_PI/180.);
1809         theRevol.Perform(Val);
1810       }
1811       else if (Kas == 4) {
1812         theDPrism.Perform(Val);
1813       }
1814       else if (Kas == 5) {
1815         theCommands << "invalid command for lf";
1816         return 1;
1817       }
1818       else if (Kas == 6) {
1819         theCommands << "invalid command for rf";
1820         return 1;
1821       }
1822     }
1823     else if(narg == 5) {
1824       Standard_Real Val = Draw::Atof(a[3]);
1825       TopoDS_Shape FUntil = DBRep::Get(a[4],TopAbs_SHAPE);
1826       if (Kas == 1) {
1827         thePrism.PerformUntilHeight(FUntil, Val);
1828       }
1829       else if (Kas == 2) {
1830         Val *=(M_PI/180.);
1831         theRevol.PerformUntilAngle(FUntil, Val);
1832       }
1833       else if (Kas == 4) {
1834         theDPrism.PerformUntilHeight(FUntil, Val);
1835       } 
1836       else {
1837         theCommands << "invalid command for ribs or slots";
1838         return 1;
1839       }
1840     }
1841   }
1842   else if (!strcasecmp(a[0],"FEATPERFORM")) {
1843     if (narg == 3) { // Thru all
1844       switch (Kas) {
1845       case 1:
1846         thePrism.PerformThruAll();
1847         break;
1848       case 2:
1849         theRevol.PerformThruAll();
1850         break;
1851       case 3:
1852         thePipe.Perform();
1853         break;
1854       case 4:
1855         theDPrism.PerformThruAll();
1856         break;
1857       case 5:
1858         theLF.Perform();
1859         break;
1860       case 6:
1861         theRF.Perform();
1862         break;
1863       default:
1864
1865         return 1;
1866       }
1867     }
1868     else if (narg == 4) { // Until
1869       TopoDS_Shape Funtil = DBRep::Get(a[3],TopAbs_SHAPE);
1870       switch (Kas) {
1871       case 1:
1872         {
1873           if (Funtil.IsNull()) {
1874             thePrism.PerformUntilEnd();
1875           }
1876           else {
1877             thePrism.Perform(Funtil);
1878           }
1879         }
1880         break;
1881       case 2:
1882         {
1883           if (!Funtil.IsNull()) {
1884             theRevol.Perform(Funtil);
1885           }
1886           else {
1887             return 1;
1888           }
1889         }
1890         break;
1891       case 3:
1892         {
1893           if (!Funtil.IsNull()) {
1894             thePipe.Perform(Funtil);
1895           }
1896           else {
1897             theCommands << "invalid command for ribs pipe";
1898             return 1;
1899           }
1900         }
1901         break;
1902       case 4:
1903         {
1904           if (!Funtil.IsNull()) {
1905             theDPrism.Perform(Funtil);
1906           }
1907           else {
1908             theDPrism.PerformUntilEnd();
1909           }
1910         }
1911         break;
1912       case 5:
1913         {  
1914           theCommands << "invalid command for lf";
1915           return 1;
1916         }
1917         break;
1918       case 6:
1919         {  
1920           theCommands << "invalid command for rf";
1921           return 1;
1922         }
1923         break;
1924       default:
1925         return 1;
1926       }
1927     }
1928     else if (narg == 5) {
1929       TopoDS_Shape Ffrom = DBRep::Get(a[3],TopAbs_SHAPE);
1930       TopoDS_Shape Funtil = DBRep::Get(a[4],TopAbs_SHAPE);
1931       if (Funtil.IsNull()) {
1932         return 1;
1933       }
1934       switch (Kas) {
1935       case 1:
1936         {
1937           if (Ffrom.IsNull()) {
1938             thePrism.PerformFromEnd(Funtil);
1939           }
1940           else {
1941             thePrism.Perform(Ffrom,Funtil);
1942           }
1943         }
1944         break;
1945       case 2:
1946         {
1947           if (Ffrom.IsNull()) {
1948             return 1;
1949           }
1950           theRevol.Perform(Ffrom,Funtil);
1951         }
1952         break;
1953       case 3:
1954         {
1955           if (Ffrom.IsNull()) {
1956             return 1;
1957           }
1958           thePipe.Perform(Ffrom,Funtil);
1959         }
1960         break;
1961       case 4:
1962         {
1963           if (Ffrom.IsNull()) {
1964             theDPrism.PerformFromEnd(Funtil);
1965           }
1966           else {
1967             theDPrism.Perform(Ffrom,Funtil);
1968           }
1969         }
1970         break;
1971
1972       default:
1973         return 1;
1974       }
1975     }
1976   }
1977
1978   BRepFeat_StatusError se;
1979   switch (Kas) {
1980   case 1:
1981     if (!thePrism.IsDone()) {
1982       se = thePrism.CurrentStatusError();
1983       //BRepFeat::Print(se,cout) << endl;
1984       Standard_SStream aSStream;
1985       BRepFeat::Print(se,aSStream);
1986       theCommands << aSStream << "\n";
1987       return 1;
1988     }
1989     DBRep::Set(a[2],thePrism);
1990     dout.Flush();
1991     return 0;
1992   case 2:
1993     if (!theRevol.IsDone()) {
1994       se = theRevol.CurrentStatusError();
1995       //BRepFeat::Print(se,cout) << endl;
1996       Standard_SStream aSStream;
1997       BRepFeat::Print(se,aSStream);
1998       theCommands << aSStream << "\n";
1999       return 1;
2000     }
2001     DBRep::Set(a[2],theRevol);
2002     dout.Flush();
2003     return 0;
2004   case 3:
2005     if (!thePipe.IsDone()) {
2006       se = thePipe.CurrentStatusError();
2007       //BRepFeat::Print(se,cout) << endl;
2008       Standard_SStream aSStream;
2009       BRepFeat::Print(se,aSStream);
2010       theCommands << aSStream << "\n";
2011       return 1;
2012     }
2013     DBRep::Set(a[2],thePipe);
2014     dout.Flush();
2015     return 0;
2016   case 4:
2017     if (!theDPrism.IsDone()) {
2018       se = theDPrism.CurrentStatusError();
2019       //BRepFeat::Print(se,cout) << endl;
2020       Standard_SStream aSStream;
2021       BRepFeat::Print(se,aSStream);
2022       theCommands << aSStream << "\n";
2023       return 1;
2024     }
2025     DBRep::Set(a[2],theDPrism);
2026     dout.Flush();
2027     return 0;
2028   case 5:
2029     if (!theLF.IsDone()) {
2030       se = theLF.CurrentStatusError();
2031       //BRepFeat::Print(se,cout) << endl;
2032       Standard_SStream aSStream;
2033       BRepFeat::Print(se,aSStream);
2034       theCommands << aSStream << "\n";
2035       return 1;
2036     }
2037     DBRep::Set(a[2],theLF);
2038     dout.Flush();
2039     return 0;
2040   case 6:
2041     if (!theRF.IsDone()) {
2042       se = theRF.CurrentStatusError();
2043       //BRepFeat::Print(se,cout) << endl;
2044       Standard_SStream aSStream;
2045       BRepFeat::Print(se,aSStream);
2046       theCommands << aSStream << "\n";
2047       return 1;
2048     }
2049     DBRep::Set(a[2],theRF);
2050     dout.Flush();
2051     return 0;
2052   default:
2053     return 1;
2054   }
2055 }
2056
2057
2058 static Standard_Integer BOSS(Draw_Interpretor& theCommands,
2059                              Standard_Integer narg, const char** a)
2060 {
2061   if (strcasecmp(a[0],"ENDEDGES") && strcasecmp(a[0],"FILLET")
2062       && strcasecmp(a[0],"BOSSAGE")) {
2063     return 1;
2064   }
2065
2066   if ((!strcasecmp(a[0],"ENDEDGES") && narg !=5) ||
2067       (!strcasecmp(a[0],"FILLET") && narg <5 &&  narg%2 != 1) ||
2068       (!strcasecmp(a[0],"BOSSAGE") && narg != 6)) {
2069     theCommands << "invalid number of arguments";
2070     return 1;
2071   }
2072
2073   Standard_Integer Kas=0;
2074   Standard_Integer dprsig=0;
2075   if (!strcasecmp("ENDEDGES",a[0])) {
2076     Kas = 1;
2077     dprsig = Draw::Atoi(a[4]);
2078   }
2079   else if (!strcasecmp("FILLET",a[0])) {
2080     Kas = 2;
2081   }
2082   else if (!strcasecmp("BOSSAGE",a[0])) {
2083     Kas = 3;
2084     dprsig = Draw::Atoi(a[5]);
2085   }
2086  
2087   TopoDS_Shape theShapeTop; 
2088   TopoDS_Shape theShapeBottom;
2089
2090   if (Kas == 1 || Kas == 3) {
2091     if (!strcasecmp("DPRISM",a[1])) {
2092       if (!dprdef) {
2093         theCommands << "dprism not defined";
2094         return 1;
2095       }
2096     }
2097     else {
2098       theCommands << "unknown argument : " << a[1];
2099       return 1;
2100     }
2101
2102     theDPrism.BossEdges(dprsig);
2103    
2104     TopTools_ListOfShape theTopEdges, theLatEdges;
2105     theTopEdges = theDPrism.TopEdges();
2106     theLatEdges = theDPrism.LatEdges();
2107
2108     TopTools_ListIteratorOfListOfShape it;
2109     BRep_Builder B;
2110
2111     B.MakeCompound(TopoDS::Compound(theShapeTop));
2112     it.Initialize(theTopEdges);
2113     for(; it.More(); it.Next()) {
2114       TopExp_Explorer exp;
2115       for (exp.Init(it.Value(),TopAbs_EDGE); exp.More(); exp.Next()) {
2116         B.Add(theShapeTop,exp.Current());
2117       }
2118     }
2119     DBRep::Set(a[2],theShapeTop);
2120     dout.Flush();
2121
2122     B.MakeCompound(TopoDS::Compound(theShapeBottom));
2123     it.Initialize(theLatEdges);
2124     for(; it.More(); it.Next()) {
2125       B.Add(theShapeBottom,it.Value());
2126     }
2127     DBRep::Set(a[3],theShapeBottom);
2128     dout.Flush();
2129     if (Kas == 1) return 0;
2130   }
2131
2132   if (Kas == 2 || Kas == 3) {
2133     
2134 //    Standard_Integer nrad;
2135     TopoDS_Shape V;
2136     if (Kas == 2) {
2137       V = DBRep::Get(a[2],TopAbs_SHAPE);
2138     }
2139     else if (Kas == 3) {
2140       V = theDPrism;
2141     }
2142
2143     if(V.IsNull()) return 1;
2144     ChFi3d_FilletShape FSh = ChFi3d_Rational;
2145     Rakk = new BRepFilletAPI_MakeFillet(V,FSh);
2146     Rakk->SetParams(ta,t3d,t2d,t3d,t2d,fl);
2147     Rakk->SetContinuity(blend_cont, tapp_angle);
2148     Standard_Real Rad;
2149     TopoDS_Shape S;
2150     TopoDS_Edge E;
2151     Standard_Integer nbedge = 0;
2152
2153     if (Kas == 2) {
2154       for (Standard_Integer ii = 1; ii < (narg-1)/2; ii++){
2155         Rad = Draw::Atof(a[2*ii + 1]);
2156         if (Rad == 0.) continue;
2157         S = DBRep::Get(a[(2*ii+2)],TopAbs_SHAPE);
2158         TopExp_Explorer exp;
2159         for (exp.Init(S,TopAbs_EDGE); exp.More(); exp.Next()) {
2160           E = TopoDS::Edge(exp.Current());
2161           if(!E.IsNull()){
2162             Rakk->Add(Rad,E);
2163             nbedge++;
2164           }
2165         }
2166       }
2167     }
2168     else if (Kas == 3) {
2169       Rad = Draw::Atof(a[3]);
2170       if (Rad != 0.) {
2171         S = theShapeTop;
2172         TopExp_Explorer exp;
2173         for (exp.Init(S,TopAbs_EDGE); exp.More(); exp.Next()) {
2174           E = TopoDS::Edge(exp.Current());
2175           if(!E.IsNull()){
2176             Rakk->Add(Rad,E);
2177             nbedge++;
2178           }
2179         } 
2180       }
2181       Rad = Draw::Atof(a[4]);
2182       if (Rad != 0.) {
2183         S = theShapeBottom;
2184         TopExp_Explorer exp;
2185         for (exp.Init(S,TopAbs_EDGE); exp.More(); exp.Next()) {
2186           E = TopoDS::Edge(exp.Current());
2187           if(!E.IsNull()){
2188             Rakk->Add(Rad,E);
2189             nbedge++;
2190           }
2191         } 
2192       }
2193     }
2194     
2195     if(!nbedge) return 1;
2196     Rakk->Build();
2197     if(!Rakk->IsDone()) return 1;
2198     TopoDS_Shape res = Rakk->Shape();
2199
2200     if (Kas == 2) {
2201       DBRep::Set(a[1],res);
2202     } 
2203     else if (Kas == 3) {
2204       DBRep::Set(a[2],res);
2205     }
2206     dout.Flush();
2207     return 0;
2208   }
2209
2210   return 1;
2211 }
2212
2213
2214 //=======================================================================
2215 //function : FeatureCommands
2216 //purpose  : 
2217 //=======================================================================
2218
2219 void BRepTest::FeatureCommands (Draw_Interpretor& theCommands)
2220 {
2221   static Standard_Boolean done = Standard_False;
2222   if (done) return;
2223   done = Standard_True;
2224
2225   DBRep::BasicCommands(theCommands);
2226
2227   const char* g = "TOPOLOGY Feature commands";
2228
2229   theCommands.Add("localope", 
2230                   " Performs a local top. operation : localope result shape tool F/C (fuse/cut) face [face...]",
2231                   __FILE__,Loc,g);
2232
2233   theCommands.Add("hole",
2234                   " Performs a hole : hole result shape Or.X Or.Y Or.Z Dir.X Dir.Y Dir.Z Radius [Pfrom Pto]",
2235                   __FILE__,HOLE1,g);
2236
2237   theCommands.Add("firsthole",
2238                   " Performs the first hole : firsthole result shape Or.X Or.Y Or.Z Dir.X Dir.Y Dir.Z Radius",
2239                   __FILE__,HOLE2,g);
2240
2241   theCommands.Add("holend",
2242                   " Performs the hole til end : holend result shape Or.X Or.Y Or.Z Dir.X Dir.Y Dir.Z Radius",
2243                   __FILE__,HOLE3,g);
2244
2245   theCommands.Add("blindhole", 
2246                   " Performs the blind hole : blindhole result shape Or.X Or.Y Or.Z Dir.X Dir.Y Dir.Z Radius Length",
2247                   __FILE__,HOLE4,g);
2248
2249   theCommands.Add("holecontrol",
2250                   "Sets/Unsets or display controls on holes : holecontrol [0/1]",
2251                   __FILE__,CONTROL,g);
2252
2253   theCommands.Add("wprism",
2254                   "Prisms wires on a face : wprism f[use]/c[ut] result shape [[FaceFrom] FaceUntil] VecX VecY VecZ  SkecthFace wire1 [wire2 ....]",
2255                   __FILE__,PRW,g);
2256
2257
2258   theCommands.Add("fprism", 
2259                   "Prisms a set of faces of a shape : fprism f[use]/c[ut] result shape [[FaceFrom] FaceUntil] VecX VecY VecZ face1 [face2...]",
2260                   __FILE__,PRF,g);
2261
2262
2263   theCommands.Add("wrotate",
2264                   "Rotates wires on a face : wrotate f[use]/c[ut] result shape Angle/[FFrom] FUntil OX OY OZ DX DY DZ SkecthFace wire1 [wire2 ....]",
2265                   __FILE__,ROW,g);
2266
2267
2268   theCommands.Add("frotate", 
2269                   "Rotates a set of faces of a shape : frotate f[use]/c[ut] result shape Angle/[FaceFrom] FaceUntil OX OY OZ DX DY DZ face1 [face2...]",
2270                   __FILE__,ROF,g);
2271
2272
2273   theCommands.Add("splitshape",
2274                   "splitshape result shape face wire/edge/compound [wire/edge/compound ...][face wire/edge/compound [wire/edge/compound...] ...] [@ edgeonshape edgeonwire [edgeonshape edgeonwire...]]",
2275                   __FILE__,SPLS,g);
2276
2277
2278   theCommands.Add("thickshell",
2279                   "thickshell r shape offset [jointype [tol] ]",
2280                   __FILE__,thickshell,g);
2281   
2282   theCommands.Add("offsetshape",
2283                   "offsetshape r shape offset [tol] [face ...]",
2284                   __FILE__,offsetshape,g);
2285   
2286   theCommands.Add("offsetcompshape",
2287                   "offsetcompshape r shape offset [face ...]",
2288                   __FILE__,offsetshape,g);
2289
2290   theCommands.Add("offsetparameter",
2291                   "offsetparameter tol inter(a/i) join(a/i)",
2292                   __FILE__,offsetparameter);
2293
2294   theCommands.Add("offsetload",
2295                   "offsetload shape offset bouchon1 bouchon2 ...",
2296                   __FILE__,offsetload,g);
2297
2298   theCommands.Add("offsetonface",
2299                   "offsetonface face1 offset1 face2 offset2 ...",
2300                   __FILE__,offsetonface,g);
2301
2302   theCommands.Add("offsetperform",
2303                   "offsetperform result",
2304                   __FILE__,offsetperform,g);
2305
2306
2307   theCommands.Add("deboucle", 
2308                   " Essai de debouclage partiel: deboucle result shape F/C face [face...] @ face [face...]",
2309                   __FILE__,Debou,g);
2310
2311
2312   theCommands.Add("glue", 
2313                   "glue result shapenew shapebase facenew facebase [facenew facebase...] [edgenew edgebase [edgenew edgebase...]]",
2314                   __FILE__,GLU,g);
2315
2316
2317   theCommands.Add("featprism", 
2318                   "Defines the arguments for a prism : featprism shape element skface  Dirx Diry Dirz Fuse(0/1/2) Modify(0/1)",
2319                   __FILE__,DEFIN);
2320
2321   theCommands.Add("featrevol", 
2322                   "Defines the arguments for a revol : featrevol shape element skface  Ox Oy Oz Dx Dy Dz Fuse(0/1/2) Modify(0/1)",
2323                   __FILE__,DEFIN);
2324
2325   theCommands.Add("featpipe", 
2326                   "Defines the arguments for a pipe : featpipe shape element skface  spine Fuse(0/1/2) Modify(0/1)",
2327                   __FILE__,DEFIN);
2328
2329   theCommands.Add("featdprism", 
2330                   "Defines the arguments for a drafted prism : featdprism shape face skface angle Fuse(0/1/2) Modify(0/1)",
2331                   __FILE__,DEFIN);
2332
2333   theCommands.Add("featlf", 
2334                   "Defines the arguments for a linear rib or slot : featlf shape wire plane DirX DirY DirZ DirX DirY DirZ Fuse(0/1/2) Modify(0/1)",
2335                   __FILE__,DEFIN);
2336
2337   theCommands.Add("featrf", 
2338                   "Defines the arguments for a rib or slot of revolution : featrf shape wire plane X Y Z DirX DirY DirZ Size Size Fuse(0/1/2) Modify(0/1)",
2339                   __FILE__,DEFIN);
2340
2341   theCommands.Add("addslide", 
2342                   " Adds sliding elements : addslide prism/revol/pipe edge face [edge face...]",
2343                   __FILE__,ADD);
2344
2345   theCommands.Add("featperform", 
2346                   " Performs the prism revol dprism linform or pipe :featperform prism/revol/pipe/dprism/lf result [[Ffrom] Funtil]",
2347                   __FILE__,PERF);
2348
2349   theCommands.Add("featperformval", 
2350                   " Performs the prism revol dprism or linform with a value :featperformval prism/revol/dprism/lf result value",
2351                   __FILE__,PERF);
2352
2353   theCommands.Add("endedges", 
2354                   " Return top and bottom edges of dprism :endedges dprism shapetop shapebottom First/LastShape (1/2)",
2355                   __FILE__,BOSS);
2356
2357   theCommands.Add("fillet", 
2358                   " Perform fillet on compounds of edges :fillet result object rad1 comp1 rad2 comp2 ...",
2359                   __FILE__,BOSS);
2360
2361   theCommands.Add("bossage", 
2362                   " Perform fillet on top and bottom edges of dprism :bossage dprism result radtop radbottom First/LastShape (1/2)",
2363                   __FILE__,BOSS);
2364
2365 }