375cad46c6032a0dfadc318421357f94606de1df
[occt.git] / src / BOPTest / BOPTest_BOPCommands.cxx
1 // Created on: 2000-03-16
2 // Created by: Peter KURNEV
3 // Copyright (c) 2000-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <BOPTest.ixx>
17
18 #include <stdio.h>
19
20 #include <DBRep.hxx>
21
22 #include <NCollection_BaseAllocator.hxx>
23 #include <NCollection_IncAllocator.hxx>
24
25 #include <TopoDS_Shape.hxx>
26 #include <TopoDS_Compound.hxx>
27 #include <BRep_Builder.hxx>
28
29 #include <BOPAlgo_PaveFiller.hxx>
30 #include <BOPAlgo_Operation.hxx>
31 #include <BOPAlgo_BOP.hxx>
32 #include <BOPAlgo_MakerVolume.hxx>
33 #include <BOPDS_DS.hxx>
34 #include <BOPTest_DrawableShape.hxx>
35 #include <BOPCol_ListOfShape.hxx>
36
37 #include <TCollection_AsciiString.hxx>
38 #include <IntTools_FaceFace.hxx>
39 #include <IntTools_Curve.hxx>
40 #include <DrawTrSurf.hxx>
41 #include <Draw_Color.hxx>
42 #include <Draw.hxx>
43 #include <BRepAlgoAPI_BooleanOperation.hxx>
44 #include <BRepAlgoAPI_Common.hxx>
45 #include <BRepAlgoAPI_Fuse.hxx>
46 #include <BRepAlgoAPI_Cut.hxx>
47 #include <BRepAlgoAPI_Section.hxx>
48
49 //
50 static BOPAlgo_PaveFiller* pPF=NULL;
51 //
52
53 static
54   Standard_Integer bopsmt(Draw_Interpretor& di,
55                           Standard_Integer n,
56                           const char** a,
57                           const BOPAlgo_Operation aOp);
58 static
59   Standard_Integer bsmt (Draw_Interpretor& di, 
60                        Standard_Integer n, 
61                        const char** a,
62                        const BOPAlgo_Operation aOp);
63 //
64 static Standard_Integer bop       (Draw_Interpretor&, Standard_Integer, const char**);
65 static Standard_Integer bopsection(Draw_Interpretor&, Standard_Integer, const char**);
66 static Standard_Integer boptuc    (Draw_Interpretor&, Standard_Integer, const char**);
67 static Standard_Integer bopcut    (Draw_Interpretor&, Standard_Integer, const char**);
68 static Standard_Integer bopfuse   (Draw_Interpretor&, Standard_Integer, const char**);
69 static Standard_Integer bopcommon (Draw_Interpretor&, Standard_Integer, const char**);
70 //
71 static Standard_Integer bsection  (Draw_Interpretor&, Standard_Integer, const char**);
72 static Standard_Integer btuc      (Draw_Interpretor&, Standard_Integer, const char**);
73 static Standard_Integer bcut      (Draw_Interpretor&, Standard_Integer, const char**);
74 static Standard_Integer bfuse     (Draw_Interpretor&, Standard_Integer, const char**);
75 static Standard_Integer bcommon   (Draw_Interpretor&, Standard_Integer, const char**);
76 //
77 static Standard_Integer bopcurves (Draw_Interpretor&, Standard_Integer, const char**);
78 static Standard_Integer bopnews   (Draw_Interpretor&, Standard_Integer, const char**);
79 //
80 static Standard_Integer bparallelmode(Draw_Interpretor&, Standard_Integer, const char**);
81 //
82 static Standard_Integer mkvolume   (Draw_Interpretor&, Standard_Integer, const char**);
83
84 //=======================================================================
85 //function : BOPCommands
86 //purpose  : 
87 //=======================================================================
88   void BOPTest::BOPCommands(Draw_Interpretor& theCommands)
89 {
90   static Standard_Boolean done = Standard_False;
91   if (done) return;
92   done = Standard_True;
93   // Chapter's name
94   const char* g = "BOP commands";
95   // Commands
96   
97   theCommands.Add("bop"       , "use bop s1 s2"   , __FILE__, bop, g);
98   theCommands.Add("bopcommon" , "use bopcommon r" , __FILE__, bopcommon, g);
99   theCommands.Add("bopfuse"   , "use bopfuse r"   , __FILE__,bopfuse, g);
100   theCommands.Add("bopcut"    , "use bopcut"      , __FILE__,bopcut, g);
101   theCommands.Add("boptuc"    , "use boptuc"      , __FILE__,boptuc, g);
102   theCommands.Add("bopsection", "use bopsection"  , __FILE__,bopsection, g);
103   //
104   theCommands.Add("bcommon" , "use bcommon r s1 s2" , __FILE__,bcommon, g);
105   theCommands.Add("bfuse"   , "use bfuse r s1 s2"   , __FILE__,bfuse, g);
106   theCommands.Add("bcut"    , "use bcut r s1 s2"    , __FILE__,bcut, g);
107   theCommands.Add("btuc"    , "use btuc r s1 s2"    , __FILE__,btuc, g);
108   theCommands.Add("bsection", "Use >bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na]", 
109                                                       __FILE__, bsection, g);
110   //
111   theCommands.Add("bopcurves", "use  bopcurves F1 F2 [-2d]", __FILE__, bopcurves, g);
112   theCommands.Add("bopnews", "use  bopnews -v[e,f]"  , __FILE__, bopnews, g);
113   theCommands.Add("bparallelmode", "bparallelmode [1/0] : show / set parallel mode for boolean operations", __FILE__, bparallelmode, g);
114   theCommands.Add("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-ni (do not intersect)] [-s (run in non parallel mode)]", __FILE__, mkvolume , g);
115 }
116
117 //=======================================================================
118 //function : bop
119 //purpose  : 
120 //=======================================================================
121 Standard_Integer bop (Draw_Interpretor& di, Standard_Integer n, const char** a)
122 {
123   char buf[32];
124   Standard_Integer iErr;
125   TopoDS_Shape aS1, aS2;
126   BOPCol_ListOfShape aLC;
127   //
128   if (n!=3) {
129     di << " use bop Shape1 Shape2\n";
130     return 1;
131   }
132   //
133   aS1=DBRep::Get(a[1]);
134   aS2=DBRep::Get(a[2]);
135   //
136   if (aS1.IsNull() || aS2.IsNull()) {
137     di << " null shapes are not allowed \n";
138     return 1;
139   }
140   //
141   aLC.Append(aS1);
142   aLC.Append(aS2);
143   //
144   if (pPF!=NULL) {
145     delete pPF;
146     pPF=NULL;
147   }
148   Handle(NCollection_BaseAllocator)aAL=new NCollection_IncAllocator;
149   pPF=new BOPAlgo_PaveFiller(aAL);
150   //
151   pPF->SetArguments(aLC);
152   //
153   pPF->Perform();
154   iErr=pPF->ErrorStatus();
155   if (iErr) {
156     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
157     di << buf;
158     return 0;
159   }
160   //
161   return 0;
162 }
163 //=======================================================================
164 //function : bopcommon
165 //purpose  : 
166 //=======================================================================
167 Standard_Integer bopcommon (Draw_Interpretor& di, Standard_Integer n, const char** a)
168 {
169   return bopsmt(di, n, a, BOPAlgo_COMMON);
170 }
171 //=======================================================================
172 //function : bopfuse
173 //purpose  : 
174 //=======================================================================
175 Standard_Integer bopfuse(Draw_Interpretor& di, Standard_Integer n, const char** a)
176 {
177   return bopsmt(di, n, a, BOPAlgo_FUSE);
178 }
179 //=======================================================================
180 //function : bopcut
181 //purpose  : 
182 //=======================================================================
183 Standard_Integer bopcut(Draw_Interpretor& di, Standard_Integer n, const char** a)
184 {
185   return bopsmt(di, n, a, BOPAlgo_CUT);
186 }
187 //=======================================================================
188 //function : boptuc
189 //purpose  : 
190 //=======================================================================
191 Standard_Integer boptuc(Draw_Interpretor& di, Standard_Integer n, const char** a)
192 {
193   return bopsmt(di, n, a, BOPAlgo_CUT21);
194 }
195 //=======================================================================
196 //function : bopsection
197 //purpose  : 
198 //=======================================================================
199 Standard_Integer bopsection(Draw_Interpretor& di, Standard_Integer n, const char** a)
200 {
201   return bopsmt(di, n, a, BOPAlgo_SECTION);
202 }
203 //=======================================================================
204 //function : bopsmt
205 //purpose  : 
206 //=======================================================================
207 Standard_Integer bopsmt(Draw_Interpretor& di,
208                         Standard_Integer n,
209                         const char** a,
210                         const BOPAlgo_Operation aOp)
211 {
212   if (n<2) {
213     di << " use bopsmt r\n";
214     return 0;
215   }
216   //
217   if (!pPF) {
218     di << " prepare PaveFiller first\n";
219     return 0;
220   }
221   //
222   if (pPF->ErrorStatus()) {
223     di << " PaveFiller has not been done\n";
224     return 0;
225   }
226   //
227   char buf[64];
228   Standard_Integer aNb, iErr;
229   BOPAlgo_BOP aBOP;
230   //
231   const BOPCol_ListOfShape& aLC=pPF->Arguments();
232   aNb=aLC.Extent();
233   if (aNb!=2) {
234     Sprintf (buf, " wrong number of arguments %s\n", aNb);
235     di << buf;
236     return 0;
237   }
238   //
239   const TopoDS_Shape& aS1=aLC.First();
240   const TopoDS_Shape& aS2=aLC.Last();
241   //
242   aBOP.AddArgument(aS1);
243   aBOP.AddTool(aS2);
244   aBOP.SetOperation(aOp);
245   //
246   aBOP.PerformWithFiller(*pPF);
247   iErr=aBOP.ErrorStatus();
248   if (iErr) {
249     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
250     di << buf;
251     return 0;
252   }
253   //
254   const TopoDS_Shape& aR=aBOP.Shape();
255   if (aR.IsNull()) {
256     di << " null shape\n";
257     return 0;
258   }
259   //
260   DBRep::Set(a[1], aR);
261   return 0;
262 }
263 //=======================================================================
264 //function : bcommon
265 //purpose  : 
266 //=======================================================================
267 Standard_Integer bcommon (Draw_Interpretor& di, Standard_Integer n, const char** a)
268 {
269   return bsmt(di, n, a, BOPAlgo_COMMON);
270 }
271 //=======================================================================
272 //function : bfuse
273 //purpose  : 
274 //=======================================================================
275 Standard_Integer bfuse (Draw_Interpretor& di, Standard_Integer n, const char** a)
276 {
277   return bsmt(di, n, a, BOPAlgo_FUSE);
278 }
279 //=======================================================================
280 //function : bcut
281 //purpose  : 
282 //=======================================================================
283 Standard_Integer bcut (Draw_Interpretor& di, Standard_Integer n, const char** a)
284 {
285   return bsmt(di, n, a, BOPAlgo_CUT);
286 }
287 //=======================================================================
288 //function : btuc
289 //purpose  : 
290 //=======================================================================
291 Standard_Integer btuc (Draw_Interpretor& di, Standard_Integer n, const char** a)
292 {
293   return bsmt(di, n, a, BOPAlgo_CUT21);
294 }
295 //=======================================================================
296 //function : bsection
297 //purpose  : 
298 //=======================================================================
299 Standard_Integer  bsection(Draw_Interpretor& di, 
300                            Standard_Integer n, 
301                            const char** a)
302 {
303   const char* usage = " Usage: bsection Result s1 s2 [-n2d/-n2d1/-n2d2] [-na]\n";
304   if (n < 4) {
305     di << usage;
306     return 1;
307   }
308
309   TopoDS_Shape aS1 = DBRep::Get(a[2]);
310   TopoDS_Shape aS2 = DBRep::Get(a[3]);
311   
312   if (aS1.IsNull() || aS2.IsNull()) {
313     di << " Null shapes are not allowed \n";
314     return 1;
315   }
316
317   Standard_Boolean bApp, bPC1, bPC2;
318   //
319   bApp = Standard_True;
320   bPC1 = Standard_True;
321   bPC2 = Standard_True;
322   
323   Standard_Boolean isbadparameter = Standard_False;
324   
325   if(n > 4) {
326     const char* key1 = a[4];
327     const char* key2 = (n > 5) ? a[5] : NULL;
328     const char* pcurveconf = NULL;
329
330     if (key1 && (!strcasecmp(key1,"-n2d") || !strcasecmp(key1,"-n2d1") || !strcasecmp(key1,"-n2d2"))) {
331       pcurveconf = key1;
332     }
333     else {
334       if (!strcasecmp(key1,"-na")) {
335         bApp = Standard_False;
336       }
337       else {
338         isbadparameter = Standard_True;
339       }
340     }
341     if (key2) {
342       if(!strcasecmp(key2,"-na")) {
343         bApp = Standard_False;
344       }
345       else {
346         isbadparameter = Standard_True;
347       }
348     }
349
350     if(!isbadparameter && pcurveconf) {      
351       if (!strcasecmp(pcurveconf, "-n2d1")) {
352         bPC1 = Standard_False;
353       }
354       else {
355         if (!strcasecmp(pcurveconf, "-n2d2")) {
356           bPC2 = Standard_False;
357         }
358         else {
359           if (!strcasecmp(pcurveconf, "-n2d")) {
360             bPC1 = Standard_False;
361             bPC2 = Standard_False;
362           }
363         }
364       }
365     }
366   }
367       
368   if(!isbadparameter) {
369     Standard_Integer iErr;
370     char buf[80];
371     //
372     BRepAlgoAPI_Section aSec(aS1, aS2, Standard_False);
373     aSec.Approximation(bApp);
374     aSec.ComputePCurveOn1(bPC1);
375     aSec.ComputePCurveOn2(bPC2);
376     //
377     aSec.Build();
378     iErr=aSec.ErrorStatus();
379     if (!aSec.IsDone()) {
380       Sprintf(buf, " ErrorStatus : %d\n",  iErr);
381       di << buf;
382       return 0;
383     }
384     //
385     const TopoDS_Shape& aR=aSec.Shape();
386     if (aR.IsNull()) {
387       di << " null shape\n";
388       return 0;
389     }
390     DBRep::Set(a[1], aR);
391     return 0;
392   }
393   else {
394     di << usage;
395     return 1;
396   }
397 }
398 //=======================================================================
399 //function : bsmt
400 //purpose  : 
401 //=======================================================================
402 Standard_Integer bsmt (Draw_Interpretor& di, 
403                        Standard_Integer n, 
404                        const char** a,
405                        const BOPAlgo_Operation aOp)
406 {
407   char buf[32];
408   Standard_Integer iErr;
409   TopoDS_Shape aS1, aS2;
410   BOPCol_ListOfShape aLC;
411   //
412   if (n!=4) {
413     di << " use bx r s1 s2\n";
414     return 1;
415   }
416   //
417   aS1=DBRep::Get(a[2]);
418   aS2=DBRep::Get(a[3]);
419   //
420   if (aS1.IsNull() || aS2.IsNull()) {
421     di << " null shapes are not allowed \n";
422     return 1;
423   }
424   aLC.Append(aS1);
425   aLC.Append(aS2);
426   //
427   Handle(NCollection_BaseAllocator)aAL=new NCollection_IncAllocator;
428   BOPAlgo_PaveFiller aPF(aAL);
429   //
430   aPF.SetArguments(aLC);
431   //
432   aPF.Perform();
433   iErr=aPF.ErrorStatus();
434   if (iErr) {
435     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
436     di << buf;
437     return 0;
438   }
439   //
440   BRepAlgoAPI_BooleanOperation* pBuilder=NULL;
441   // 
442   if (aOp==BOPAlgo_COMMON) {
443     pBuilder=new BRepAlgoAPI_Common(aS1, aS2, aPF);
444   }
445   else if (aOp==BOPAlgo_FUSE) {
446     pBuilder=new BRepAlgoAPI_Fuse(aS1, aS2, aPF);
447   }
448   else if (aOp==BOPAlgo_CUT) {
449     pBuilder=new BRepAlgoAPI_Cut (aS1, aS2, aPF);
450   }
451   else if (aOp==BOPAlgo_CUT21) {
452     pBuilder=new BRepAlgoAPI_Cut(aS1, aS2, aPF, Standard_False);
453   }
454   //
455   iErr = pBuilder->ErrorStatus();
456   if (!pBuilder->IsDone()) {
457     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
458     di << buf;
459     return 0;
460   }
461   const TopoDS_Shape& aR=pBuilder->Shape();
462   if (aR.IsNull()) {
463     di << " null shape\n";
464     return 0;
465   }
466   DBRep::Set(a[1], aR);
467   return 0;
468 }
469
470 //=======================================================================
471 //function : bopnews
472 //purpose  : 
473 //=======================================================================
474 Standard_Integer bopnews (Draw_Interpretor& di, 
475                           Standard_Integer n, 
476                           const char** a)
477 {
478   if (n!=2) {
479     di << " use bopnews -v[e,f]\n";
480     return 0;
481   }
482   //
483   if (pPF==NULL) {
484     di << " Prepare BOPAlgo_PaveFiller first >bop S1 S2\n";
485     return 0;
486   }
487   //
488   char buf[32];
489   Standard_CString aText;
490   Standard_Integer i, i1, i2, iFound;
491   Draw_Color aTextColor(Draw_cyan);
492   TopAbs_ShapeEnum aT;
493   Handle(BOPTest_DrawableShape) aDShape;
494   //
495   const BOPDS_PDS& pDS=pPF->PDS();
496   //
497   aT=TopAbs_SHAPE;
498   if (!strcmp (a[1], "-f")) {
499     aT=TopAbs_FACE;
500   }
501   else if (!strcmp (a[1], "-e")){
502     aT=TopAbs_EDGE;
503   }
504   else if (!strcmp (a[1], "-v")){
505     aT=TopAbs_VERTEX;
506   }
507   else {
508     di << " use bopnews -v[e,f]\n";
509     return 0;
510   }
511   //
512   iFound=0;
513   i1=pDS->NbSourceShapes();
514   i2=pDS->NbShapes();
515   for (i=i1; i<i2; ++i) {
516     const BOPDS_ShapeInfo& aSI=pDS->ShapeInfo(i);
517     if (aSI.ShapeType()==aT) {
518       const TopoDS_Shape& aS=aSI.Shape();
519       //
520       Sprintf (buf, "z%d", i);
521       aText=buf;
522       aDShape=new BOPTest_DrawableShape (aS, aText, aTextColor);
523       Draw::Set (aText, aDShape);
524       //
525       Sprintf (buf, " z%d", i);
526       di << buf;
527       //
528       iFound=1;
529     }
530   }
531   //
532   if (iFound) {
533     di << "\n";
534   }
535   else {
536     di << " not found\n";
537   }
538   //
539   return 0;
540 }
541
542 //=======================================================================
543 //function : bopcurves
544 //purpose  : 
545 //=======================================================================
546 Standard_Integer bopcurves (Draw_Interpretor& di, 
547                             Standard_Integer n, 
548                             const char** a)
549 {
550   if (n<3) {
551     di << " use bopcurves F1 F2 [-2d]\n";
552     return 1;
553   }
554
555   TopoDS_Shape S1 = DBRep::Get(a[1]);
556   TopoDS_Shape S2 = DBRep::Get(a[2]);
557   TopAbs_ShapeEnum aType;
558
559   if (S1.IsNull() || S2.IsNull()) {
560     di << " Null shapes is not allowed \n";
561     return 1;
562   }
563
564   aType=S1.ShapeType();
565   if (aType != TopAbs_FACE) {
566     di << " Type mismatch F1\n";
567     return 1;
568   }
569   aType=S2.ShapeType();
570   if (aType != TopAbs_FACE) {
571     di << " Type mismatch F2\n";
572     return 1;
573   }
574
575
576   const TopoDS_Face& aF1=*(TopoDS_Face*)(&S1);
577   const TopoDS_Face& aF2=*(TopoDS_Face*)(&S2);
578
579   Standard_Boolean aToApproxC3d, aToApproxC2dOnS1, aToApproxC2dOnS2, anIsDone, bMake2dCurves;
580   Standard_Integer i, aNbCurves;
581   Standard_Real anAppTol, aTolR;
582   TCollection_AsciiString aNm("c_");
583
584   bMake2dCurves = Standard_False;
585   if (n > 3) {
586     if (!strcasecmp(a[3],"-2d")) {
587       bMake2dCurves = Standard_True;
588     } else {
589       di << "Wrong key. To build 2d curves use: bopcurves F1 F2 -2d \n";
590       return 1;
591     }
592   }
593   //
594
595   aToApproxC3d = Standard_True;
596   aToApproxC2dOnS1 = bMake2dCurves;
597   aToApproxC2dOnS2 = bMake2dCurves;
598   anAppTol=0.0000001;
599
600
601   IntTools_FaceFace aFF;
602   
603   aFF.SetParameters (aToApproxC3d,
604                      aToApproxC2dOnS1,
605                      aToApproxC2dOnS2,
606                      anAppTol);
607   
608   aFF.Perform (aF1, aF2);
609   
610   anIsDone=aFF.IsDone();
611   if (!anIsDone) {
612     di << " anIsDone=" << (Standard_Integer) anIsDone << "\n";
613     return 1;
614   }
615
616   aFF.PrepareLines3D(Standard_False);
617   const IntTools_SequenceOfCurves& aSCs=aFF.Lines();
618
619   //
620   aTolR=aFF.TolReached3d();
621   di << "Tolerance Reached=" << aTolR << "\n";
622
623   aNbCurves=aSCs.Length();
624   if (!aNbCurves) {
625     di << " has no 3d curve\n";
626     return 1;
627   }
628   else
629   {
630     di << aNbCurves << " curve(s) found.\n";
631   }
632
633   for (i=1; i<=aNbCurves; i++) {
634     const IntTools_Curve& anIC=aSCs(i);
635
636     Handle (Geom_Curve)  aC3D = anIC.Curve();
637
638     if (aC3D.IsNull()) {
639       di << " has Null 3d curve# " << i << "\n";
640       continue;
641     }
642
643     TCollection_AsciiString anIndx(i), aNmx;
644     aNmx = aNm + anIndx;
645
646     Standard_CString nameC = aNmx.ToCString();
647
648     DrawTrSurf::Set(nameC, aC3D);
649     di << nameC << " ";
650     //
651     if (bMake2dCurves) {
652       Handle(Geom2d_Curve) aPC1 = anIC.FirstCurve2d();
653       Handle(Geom2d_Curve) aPC2 = anIC.SecondCurve2d();
654       //
655       if (aPC1.IsNull() && aPC2.IsNull()) {
656         di << " \n has Null 2d curves# " << i << "\n";
657         continue;
658       }
659       //
660       if (aPC1.IsNull()) {
661         TCollection_AsciiString pc2N("c2d2_"), pc2Nx;
662         pc2Nx = pc2N + anIndx;
663         Standard_CString nameC2d2 = pc2Nx.ToCString();
664         //
665         DrawTrSurf::Set(nameC2d2, aPC2);
666         di << "(" << nameC2d2 << ") ";
667         di << " \n Null first 2d curve of the curve #" << i << "\n";
668         continue;
669       } else {
670         TCollection_AsciiString pc1N("c2d1_"), pc1Nx;
671         pc1Nx = pc1N + anIndx;
672         Standard_CString nameC2d1 = pc1Nx.ToCString();
673         //
674         DrawTrSurf::Set(nameC2d1, aPC1);
675         di << "(" << nameC2d1;
676       }
677       //
678       if (aPC2.IsNull()) {
679         di << ") \n Null second 2d curve of the curve #" << i << "\n";
680         continue;
681       } else {
682         TCollection_AsciiString pc2N("c2d2_"), pc2Nx;
683         pc2Nx = pc2N + anIndx;
684         Standard_CString nameC2d2 = pc2Nx.ToCString();
685         //
686         DrawTrSurf::Set(nameC2d2, aPC2);
687         di << ", " << nameC2d2 << ") ";
688       }
689     }
690   }
691
692   di << "\n";
693   
694   return 0;
695 }
696
697 //=======================================================================
698 //function : bparallelmode
699 //purpose  : 
700 //=======================================================================
701 Standard_Integer bparallelmode(Draw_Interpretor& di, Standard_Integer n, const char** a)
702 {
703   if (n == 2)
704   {
705     Standard_Boolean isParallelOn = Draw::Atoi (a[1]) == 1;
706     if (isParallelOn == 1)
707     {
708       BOPAlgo_Algo::SetParallelMode(Standard_True);
709       di << "Parallel mode for boolean operations has been enabled";
710     }
711     else
712     {
713       BOPAlgo_Algo::SetParallelMode(Standard_False);
714       di << "Parallel mode for boolean operations has been disabled";
715     }
716   }
717   else
718   {
719     di << "Parallel mode state for boolean operations: "
720        << (BOPAlgo_Algo::GetParallelMode()? "enabled" : "disabled");
721   }
722
723   return 0;
724 }
725
726 //=======================================================================
727 //function : mkvolume
728 //purpose  : 
729 //=======================================================================
730 Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char** a) 
731 {
732   const char* usage = "Usage: mkvolume r b1 b2 ... [-ni (do not intersect)] [-s (run in non parallel mode)]\n";
733   if (n < 3) {
734     di << usage;
735     return 1;
736   }
737   //
738   Standard_Boolean bToIntersect, bRunParallel;
739   Standard_Integer i, aNb;
740   //
741   aNb = n;
742   bToIntersect = Standard_True;
743   bRunParallel = Standard_True;
744   //
745   if (!strcmp(a[n-1], "-ni")) {
746     bToIntersect = Standard_False;
747     aNb = n-1;
748   } 
749   else if (!strcmp(a[n-1], "-s")) {
750     bRunParallel = Standard_False;
751     aNb = n-1;
752   }
753   if (n > 3) {
754     if (!strcmp(a[n-2], "-ni")) {
755       bToIntersect = Standard_False;
756       aNb = n-2;
757     } 
758     else if (!strcmp(a[n-2], "-s")) {
759       bRunParallel = Standard_False;
760       aNb = n-2;
761     }
762   }
763   //
764   if (aNb < 3) {
765     di << "no shapes to process.\n";
766     di << usage;
767     return 1;
768   }
769   //
770   BOPCol_ListOfShape aLS;
771   TopoDS_Shape aS;
772   for (i = 2; i < aNb; ++i) {
773     aS = DBRep::Get(a[i]);
774     if (!aS.IsNull()) {
775       aLS.Append(aS);
776     }
777   }
778   //
779   if (aLS.IsEmpty()) {
780     di << "no shapes to process.\n";
781     di << usage;
782     return 1;
783   }
784   //
785   BOPAlgo_MakerVolume aMV;
786   aMV.SetArguments(aLS);
787   aMV.SetIntersect(bToIntersect);
788   aMV.SetRunParallel(bRunParallel);
789   //
790   aMV.Perform();
791   if (aMV.ErrorStatus()) {
792     di << "Error status: " << aMV.ErrorStatus();
793     return 1;
794   }
795   //
796   const TopoDS_Shape& aR = aMV.Shape();
797   //
798   DBRep::Set(a[1], aR);
799   //
800   return 0;
801 }
802