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