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