0026841: Boolean operation "bsection" produce invalid result on the attached cases
[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
17 #include <BOPAlgo_BOP.hxx>
18 #include <BOPAlgo_MakerVolume.hxx>
19 #include <BOPAlgo_Operation.hxx>
20 #include <BOPAlgo_PaveFiller.hxx>
21 #include <BOPAlgo_Section.hxx>
22 #include <BOPCol_ListOfShape.hxx>
23 #include <BOPDS_DS.hxx>
24 #include <BOPTest.hxx>
25 #include <BOPTest_Objects.hxx>
26 #include <BRep_Builder.hxx>
27 #include <BRepAlgoAPI_BooleanOperation.hxx>
28 #include <BRepAlgoAPI_Common.hxx>
29 #include <BRepAlgoAPI_Cut.hxx>
30 #include <BRepAlgoAPI_Fuse.hxx>
31 #include <BRepAlgoAPI_Section.hxx>
32 #include <DBRep.hxx>
33 #include <Draw.hxx>
34 #include <DrawTrSurf.hxx>
35 #include <Geom2d_Curve.hxx>
36 #include <Geom_Curve.hxx>
37 #include <IntTools_Curve.hxx>
38 #include <IntTools_FaceFace.hxx>
39 #include <IntTools_PntOn2Faces.hxx>
40 #include <NCollection_BaseAllocator.hxx>
41 #include <TCollection_AsciiString.hxx>
42 #include <TopoDS_Compound.hxx>
43 #include <TopoDS_Iterator.hxx>
44 #include <TopoDS_Shape.hxx>
45
46 #include <stdio.h>
47 //
48 //
49 static BOPAlgo_PaveFiller* pPF=NULL;
50 //
51
52 static
53   Standard_Integer bopsmt(Draw_Interpretor& di,
54                           Standard_Integer n,
55                           const char** a,
56                           const BOPAlgo_Operation aOp);
57 //
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 mkvolume   (Draw_Interpretor&, Standard_Integer, const char**);
79
80 //=======================================================================
81 //function : BOPCommands
82 //purpose  : 
83 //=======================================================================
84   void BOPTest::BOPCommands(Draw_Interpretor& theCommands)
85 {
86   static Standard_Boolean done = Standard_False;
87   if (done) return;
88   done = Standard_True;
89   // Chapter's name
90   const char* g = "BOPTest commands";
91   // Commands
92   
93   theCommands.Add("bop"       , "use bop s1 s2" , __FILE__, bop, g);
94   theCommands.Add("bopcommon" , "use bopcommon r"     , __FILE__, bopcommon, g);
95   theCommands.Add("bopfuse"   , "use bopfuse r"       , __FILE__,bopfuse, g);
96   theCommands.Add("bopcut"    , "use bopcut r"        , __FILE__,bopcut, g);
97   theCommands.Add("boptuc"    , "use boptuc r"        , __FILE__,boptuc, g);
98   theCommands.Add("bopsection", "use bopsection r"    , __FILE__,bopsection, g);
99   //
100   theCommands.Add("bcommon" , "use bcommon r s1 s2" , __FILE__,bcommon, g);
101   theCommands.Add("bfuse"   , "use bfuse r s1 s2"   , __FILE__,bfuse, g);
102   theCommands.Add("bcut"    , "use bcut r s1 s2"    , __FILE__,bcut, g);
103   theCommands.Add("btuc"    , "use btuc r s1 s2"    , __FILE__,btuc, g);
104   theCommands.Add("bsection", "use bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na]", 
105                                                       __FILE__, bsection, g);
106   //
107   theCommands.Add("bopcurves", "use bopcurves F1 F2 [-2d/-2d1/-2d2] [-p u1 v1 u2 v2]",
108                                                       __FILE__, bopcurves, g);
109   theCommands.Add("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-c] [-ni]", 
110                   __FILE__, mkvolume , g);
111 }
112
113 //=======================================================================
114 //function : bop
115 //purpose  : 
116 //=======================================================================
117 Standard_Integer bop(Draw_Interpretor& di, 
118                      Standard_Integer n, 
119                      const char** a)
120 {
121   char buf[32];
122   Standard_Boolean bRunParallel;
123   Standard_Integer iErr;
124   Standard_Real aTol;
125   TopoDS_Shape aS1, aS2;
126   BOPCol_ListOfShape aLC;
127   //
128   if (n != 3) {
129     di << " use bop s1 s2 \n";
130     return 0;
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 0;
139   }
140   //
141   aTol=BOPTest_Objects::FuzzyValue();
142   bRunParallel=BOPTest_Objects::RunParallel();
143   //
144   aLC.Append(aS1);
145   aLC.Append(aS2);
146   //
147   if (pPF!=NULL) {
148     delete pPF;
149     pPF=NULL;
150   }
151   Handle(NCollection_BaseAllocator)aAL=
152     NCollection_BaseAllocator::CommonBaseAllocator();
153   pPF=new BOPAlgo_PaveFiller(aAL);
154   //
155   pPF->SetArguments(aLC);
156   pPF->SetFuzzyValue(aTol);
157   pPF->SetRunParallel(bRunParallel);
158   //
159   pPF->Perform();
160   iErr=pPF->ErrorStatus();
161   if (iErr) {
162     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
163     di << buf;
164     return 0;
165   }
166   //
167   return 0;
168 }
169 //=======================================================================
170 //function : bopcommon
171 //purpose  : 
172 //=======================================================================
173 Standard_Integer bopcommon (Draw_Interpretor& di, 
174                             Standard_Integer n, 
175                             const char** a)
176 {
177   return bopsmt(di, n, a, BOPAlgo_COMMON);
178 }
179 //=======================================================================
180 //function : bopfuse
181 //purpose  : 
182 //=======================================================================
183 Standard_Integer bopfuse(Draw_Interpretor& di, 
184                          Standard_Integer n, 
185                          const char** a)
186 {
187   return bopsmt(di, n, a, BOPAlgo_FUSE);
188 }
189 //=======================================================================
190 //function : bopcut
191 //purpose  : 
192 //=======================================================================
193 Standard_Integer bopcut(Draw_Interpretor& di, 
194                         Standard_Integer n, 
195                         const char** a)
196 {
197   return bopsmt(di, n, a, BOPAlgo_CUT);
198 }
199 //=======================================================================
200 //function : boptuc
201 //purpose  : 
202 //=======================================================================
203 Standard_Integer boptuc(Draw_Interpretor& di, 
204                         Standard_Integer n, 
205                         const char** a)
206 {
207   return bopsmt(di, n, a, BOPAlgo_CUT21);
208 }
209 //=======================================================================
210 //function : bopsmt
211 //purpose  : 
212 //=======================================================================
213 Standard_Integer bopsmt(Draw_Interpretor& di,
214                         Standard_Integer n,
215                         const char** a,
216                         const BOPAlgo_Operation aOp)
217 {
218   if (n<2) {
219     di << " use bopsmt r\n";
220     return 0;
221   }
222   //
223   if (!pPF) {
224     di << " prepare PaveFiller first\n";
225     return 0;
226   }
227   //
228   if (pPF->ErrorStatus()) {
229     di << " PaveFiller has not been done\n";
230     return 0;
231   }
232   //
233   char buf[64];
234   Standard_Boolean bRunParallel;
235   Standard_Integer aNb, iErr;
236   BOPAlgo_BOP aBOP;
237   //
238   const BOPCol_ListOfShape& aLC=pPF->Arguments();
239   aNb=aLC.Extent();
240   if (aNb!=2) {
241     Sprintf (buf, " wrong number of arguments %s\n", aNb);
242     di << buf;
243     return 0;
244   }
245   // 
246   bRunParallel=BOPTest_Objects::RunParallel();
247   //
248   const TopoDS_Shape& aS1=aLC.First();
249   const TopoDS_Shape& aS2=aLC.Last();
250   //
251   aBOP.AddArgument(aS1);
252   aBOP.AddTool(aS2);
253   aBOP.SetOperation(aOp);
254   aBOP.SetRunParallel (bRunParallel);
255   //
256   aBOP.PerformWithFiller(*pPF);
257   iErr=aBOP.ErrorStatus();
258   if (iErr) {
259     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
260     di << buf;
261     return 0;
262   }
263   //
264   const TopoDS_Shape& aR=aBOP.Shape();
265   if (aR.IsNull()) {
266     di << " null shape\n";
267     return 0;
268   }
269   //
270   DBRep::Set(a[1], aR);
271   return 0;
272 }
273 //=======================================================================
274 //function : bopsection
275 //purpose  : 
276 //=======================================================================
277 Standard_Integer bopsection(Draw_Interpretor& di, 
278                             Standard_Integer n, 
279                             const char** a)
280 {
281   if (n<2) {
282     di << " use bopsection r\n";
283     return 0;
284   }
285   //
286   if (!pPF) {
287     di << " prepare PaveFiller first\n";
288     return 0;
289   }
290   //
291   if (pPF->ErrorStatus()) {
292     di << " PaveFiller has not been done\n";
293     return 0;
294   }
295   //
296   char buf[64];
297   Standard_Boolean bRunParallel;
298   Standard_Integer aNb, iErr;
299   BOPAlgo_Section aBOP;
300   //
301   const BOPCol_ListOfShape& aLC=pPF->Arguments();
302   aNb=aLC.Extent();
303   if (aNb!=2) {
304     Sprintf (buf, " wrong number of arguments %s\n", aNb);
305     di << buf;
306     return 0;
307   }
308   //
309   bRunParallel=BOPTest_Objects::RunParallel();
310   //
311   const TopoDS_Shape& aS1=aLC.First();
312   const TopoDS_Shape& aS2=aLC.Last();
313   //
314   aBOP.AddArgument(aS1);
315   aBOP.AddArgument(aS2);
316   aBOP.SetRunParallel (bRunParallel);
317   //
318   aBOP.PerformWithFiller(*pPF);
319   iErr=aBOP.ErrorStatus();
320   if (iErr) {
321     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
322     di << buf;
323     return 0;
324   }
325   //
326   const TopoDS_Shape& aR=aBOP.Shape();
327   if (aR.IsNull()) {
328     di << " null shape\n";
329     return 0;
330   }
331   //
332   DBRep::Set(a[1], aR);
333   return 0;
334 }
335 //=======================================================================
336 //function : bcommon
337 //purpose  : 
338 //=======================================================================
339 Standard_Integer bcommon (Draw_Interpretor& di, 
340                           Standard_Integer n, 
341                           const char** a)
342 {
343   return bsmt(di, n, a, BOPAlgo_COMMON);
344 }
345 //=======================================================================
346 //function : bfuse
347 //purpose  : 
348 //=======================================================================
349 Standard_Integer bfuse (Draw_Interpretor& di, 
350                         Standard_Integer n, 
351                         const char** a)
352 {
353   return bsmt(di, n, a, BOPAlgo_FUSE);
354 }
355 //=======================================================================
356 //function : bcut
357 //purpose  : 
358 //=======================================================================
359 Standard_Integer bcut (Draw_Interpretor& di, 
360                        Standard_Integer n, 
361                        const char** a)
362 {
363   return bsmt(di, n, a, BOPAlgo_CUT);
364 }
365 //=======================================================================
366 //function : btuc
367 //purpose  : 
368 //=======================================================================
369 Standard_Integer btuc (Draw_Interpretor& di, 
370                        Standard_Integer n, 
371                        const char** a)
372 {
373   return bsmt(di, n, a, BOPAlgo_CUT21);
374 }
375 //=======================================================================
376 //function : bsection
377 //purpose  : 
378 //=======================================================================
379 Standard_Integer  bsection(Draw_Interpretor& di, 
380                            Standard_Integer n, 
381                            const char** a)
382 {
383   if (n < 4) {
384     di << "use bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na] [tol]\n";
385     return 0;
386   }
387   //
388   TopoDS_Shape aS1, aS2;
389   //
390   aS1=DBRep::Get(a[2]);
391   aS2=DBRep::Get(a[3]);
392   if (aS1.IsNull() || aS2.IsNull()) {
393     di << " Null shapes are not allowed \n";
394     return 0;
395   }
396   // 
397   char buf[80];
398   Standard_Boolean bRunParallel, bApp, bPC1, bPC2;
399   Standard_Integer i, iErr;
400   Standard_Real aTol;
401   //
402   bApp = Standard_True;
403   bPC1 = Standard_True;
404   bPC2 = Standard_True;
405   aTol = BOPTest_Objects::FuzzyValue(); 
406   bRunParallel = BOPTest_Objects::RunParallel();
407   //
408   for (i = 4; i < n; ++i) {
409     if (!strcmp(a[i], "-n2d")) {
410       bPC1 = Standard_False;
411       bPC2 = Standard_False;
412     }
413     else if (!strcmp(a[i], "-n2d1")) {
414       bPC1 = Standard_False;
415     }
416     else if (!strcmp(a[i], "-n2d2")) {
417       bPC2 = Standard_False;
418     }
419     else if (!strcmp(a[i], "-na")) {
420       bApp = Standard_False;
421     }
422   }
423   //
424   BRepAlgoAPI_Section aSec(aS1, aS2, Standard_False);
425   //
426   aSec.Approximation(bApp);
427   aSec.ComputePCurveOn1(bPC1);
428   aSec.ComputePCurveOn2(bPC2);
429   //
430   aSec.SetFuzzyValue(aTol);
431   aSec.SetRunParallel(bRunParallel);
432   //
433   aSec.Build();
434   iErr=aSec.ErrorStatus();
435   if (!aSec.IsDone()) {
436     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
437     di << buf;
438     return 0;
439   }
440   //
441   const TopoDS_Shape& aR=aSec.Shape();
442   if (aR.IsNull()) {
443     di << " null shape\n";
444     return 0;
445   }
446   DBRep::Set(a[1], aR);
447   return 0;
448 }
449 //=======================================================================
450 //function : bsmt
451 //purpose  : 
452 //=======================================================================
453 Standard_Integer bsmt (Draw_Interpretor& di, 
454                        Standard_Integer n, 
455                        const char** a,
456                        const BOPAlgo_Operation aOp)
457 {
458   char buf[32];
459   Standard_Boolean bRunParallel;
460   Standard_Integer iErr;
461   TopoDS_Shape aS1, aS2;
462   BOPCol_ListOfShape aLC;
463   Standard_Real aTol;
464   //
465   if (n != 4) {
466     di << " use bx r s1 s2\n";
467     return 0;
468   }
469   //
470   aS1=DBRep::Get(a[2]);
471   aS2=DBRep::Get(a[3]);
472   //
473   if (aS1.IsNull() || aS2.IsNull()) {
474     di << " null shapes are not allowed \n";
475     return 0;
476   }
477   aLC.Append(aS1);
478   aLC.Append(aS2);
479   // 
480   aTol=BOPTest_Objects::FuzzyValue();
481   bRunParallel = BOPTest_Objects::RunParallel();
482   //
483   Handle(NCollection_BaseAllocator)aAL=
484     NCollection_BaseAllocator::CommonBaseAllocator();
485   //
486   //---------------------------------------------------------------
487   BOPAlgo_PaveFiller aPF(aAL);
488   //
489   aPF.SetArguments(aLC);
490   aPF.SetFuzzyValue(aTol); 
491   aPF.SetRunParallel(bRunParallel);
492   //
493   aPF.Perform();
494   iErr=aPF.ErrorStatus();
495   if (iErr) {
496     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
497     di << buf;
498     return 0;
499   }
500   //
501   //---------------------------------------------------------------
502   BOPAlgo_BOP aBOP(aAL);
503   //
504   aBOP.AddArgument(aS1);
505   aBOP.AddTool(aS2);
506   aBOP.SetOperation(aOp);
507   aBOP.SetRunParallel(bRunParallel);
508   // 
509   aBOP.PerformWithFiller(aPF);
510   //
511   iErr=aBOP.ErrorStatus();
512   if (iErr) {
513     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
514     di << buf;
515     return 0;
516   }
517   const TopoDS_Shape& aR=aBOP.Shape();
518   if (aR.IsNull()) {
519     di << " null shape\n";
520     return 0;
521   }
522   //
523   DBRep::Set(a[1], aR);
524   return 0;
525 }
526 //=======================================================================
527 //function : bopcurves
528 //purpose  : 
529 //=======================================================================
530 Standard_Integer bopcurves (Draw_Interpretor& di, 
531                             Standard_Integer n, 
532                             const char** a)
533 {
534   if (n<3) {
535     di << " use bopcurves F1 F2 [-2d/-2d1/-2d2]\n";
536     return 1;
537   }
538   //
539   TopoDS_Shape S1 = DBRep::Get(a[1]);
540   TopoDS_Shape S2 = DBRep::Get(a[2]);
541   TopAbs_ShapeEnum aType;
542   //
543   if (S1.IsNull() || S2.IsNull()) {
544     di << " Null shapes is not allowed \n";
545     return 1;
546   }
547   //
548   aType=S1.ShapeType();
549   if (aType != TopAbs_FACE) {
550     di << " Type mismatch F1\n";
551     return 1;
552   }
553   aType=S2.ShapeType();
554   if (aType != TopAbs_FACE) {
555     di << " Type mismatch F2\n";
556     return 1;
557   }
558   //
559   const TopoDS_Face& aF1=*(TopoDS_Face*)(&S1);
560   const TopoDS_Face& aF2=*(TopoDS_Face*)(&S2);
561   //
562   Standard_Boolean aToApproxC3d, aToApproxC2dOnS1, aToApproxC2dOnS2, anIsDone;
563   Standard_Integer i, aNbCurves, aNbPoints;
564   Standard_Real anAppTol, aTolR;
565   IntSurf_ListOfPntOn2S aListOfPnts;
566   TCollection_AsciiString aNm("c_"), aNp("p_");
567   //
568   anAppTol = 0.0000001;
569   aToApproxC3d = Standard_True;
570   aToApproxC2dOnS1 = Standard_False;
571   aToApproxC2dOnS2 = Standard_False;
572
573   //
574   for(Standard_Integer i = 3; i < n; i++)
575   {
576     if (!strcasecmp(a[i],"-2d")) {
577       aToApproxC2dOnS1 = Standard_True;
578       aToApproxC2dOnS2 = Standard_True;
579     } 
580     else if (!strcasecmp(a[i],"-2d1")) {
581       aToApproxC2dOnS1 = Standard_True;
582     }
583     else if (!strcasecmp(a[i],"-2d2")) {
584       aToApproxC2dOnS2 = Standard_True;
585     }
586     else if (!strcasecmp(a[i],"-p")) {
587       IntSurf_PntOn2S aPt;
588       const Standard_Real aU1 = Draw::Atof(a[++i]);
589       const Standard_Real aV1 = Draw::Atof(a[++i]);
590       const Standard_Real aU2 = Draw::Atof(a[++i]);
591       const Standard_Real aV2 = Draw::Atof(a[++i]);
592
593       aPt.SetValue(aU1, aV1, aU2, aV2);
594       aListOfPnts.Append(aPt);
595     }
596     else {
597       di << "Wrong key. To build 2d curves use: bopcurves F1 F2 [-2d/-2d1/-2d2] [-p u1 v1 u2 v2]\n";
598       return 1;
599     }
600
601   }
602
603   //
604   IntTools_FaceFace aFF;
605   //
606   aFF.SetParameters (aToApproxC3d,
607                      aToApproxC2dOnS1,
608                      aToApproxC2dOnS2,
609                      anAppTol);
610   aFF.SetList(aListOfPnts);
611   //
612   aFF.Perform (aF1, aF2);
613   //
614   anIsDone=aFF.IsDone();
615   if (!anIsDone) {
616     di << "Error: anIsDone=" << (Standard_Integer) anIsDone << "\n";
617     return 0;
618   }
619   //
620   aFF.PrepareLines3D(Standard_False);
621   const IntTools_SequenceOfCurves& aSCs=aFF.Lines();
622   const IntTools_SequenceOfPntOn2Faces& aSPs = aFF.Points();
623   //
624   aNbCurves = aSCs.Length();
625   aNbPoints = aSPs.Length();
626   if (!aNbCurves && !aNbPoints) {
627     di << " has no 3d curves\n";
628     di << " has no 3d points\n";
629     return 0;
630   }
631   //
632   aTolR=aFF.TolReached3d();
633   di << "Tolerance Reached=" << aTolR << "\n";
634   //
635   // curves
636   if (aNbCurves) {
637     di << aNbCurves << " curve(s) found.\n";
638     //
639     for (i=1; i<=aNbCurves; i++) {
640       const IntTools_Curve& anIC=aSCs(i);
641
642       Handle (Geom_Curve)  aC3D = anIC.Curve();
643
644       if (aC3D.IsNull()) {
645         di << " has Null 3d curve# " << i << "\n";
646         continue;
647       }
648
649       TCollection_AsciiString anIndx(i), aNmx;
650       aNmx = aNm + anIndx;
651
652       Standard_CString nameC = aNmx.ToCString();
653
654       DrawTrSurf::Set(nameC, aC3D);
655       di << nameC << " ";
656       //
657       Handle(Geom2d_Curve) aPC1 = anIC.FirstCurve2d();
658       Handle(Geom2d_Curve) aPC2 = anIC.SecondCurve2d();
659       //
660       if (!aPC1.IsNull() || !aPC2.IsNull()) {
661         di << "(";
662         //
663         if (!aPC1.IsNull()) {
664           TCollection_AsciiString pc1N("c2d1_"), pc1Nx;
665           pc1Nx = pc1N + anIndx;
666           Standard_CString nameC2d1 = pc1Nx.ToCString();
667           //
668           DrawTrSurf::Set(nameC2d1, aPC1);
669           di << nameC2d1;
670         }
671         //
672         if (!aPC2.IsNull()) {
673           TCollection_AsciiString pc2N("c2d2_"), pc2Nx;
674           pc2Nx = pc2N + anIndx;
675           Standard_CString nameC2d2 = pc2Nx.ToCString();
676           //
677           DrawTrSurf::Set(nameC2d2, aPC2);
678           //
679           if (!aPC1.IsNull()) {
680             di << ", ";
681           }
682           di << nameC2d2;
683         }
684         di << ") ";
685       }
686     }
687     di << "\n";
688   }
689   //
690   // points
691   if (aNbPoints) {
692     di << aNbPoints << " point(s) found.\n";
693     //
694     for (i = 1; i <= aNbPoints; i++) {
695       const IntTools_PntOn2Faces& aPi = aSPs(i);
696       const gp_Pnt& aP = aPi.P1().Pnt();
697       //
698       TCollection_AsciiString anIndx(i), aNmx;
699       aNmx = aNp + anIndx;
700       Standard_CString nameP = aNmx.ToCString();
701       //
702       DrawTrSurf::Set(nameP, aP);
703       di << nameP << " ";
704     }
705     di << "\n";
706   }
707   //
708   return 0;
709 }
710 //=======================================================================
711 //function : mkvolume
712 //purpose  : 
713 //=======================================================================
714 Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char** a) 
715 {
716   if (n < 3) {
717     di << "Usage: mkvolume r b1 b2 ... [-c] [-ni]\n";
718     di << "Options:\n";
719     di << " -c  - use this option if the arguments are compounds\n";
720     di << "       containing shapes that should be interfered;\n";
721     di << " -ni - use this option if the arguments should not be interfered;\n";
722     return 1;
723   }
724   //
725   const char* usage = "Type mkvolume without arguments for the usage of the command.\n";
726   //
727   Standard_Boolean bToIntersect, bRunParallel, bCompounds;
728   Standard_Integer i;
729   Standard_Real aTol;
730   TopoDS_Shape aS;
731   BOPCol_ListOfShape aLS;
732   //
733   aTol = BOPTest_Objects::FuzzyValue();
734   bRunParallel = BOPTest_Objects::RunParallel();
735   //
736   bToIntersect = Standard_True;
737   bCompounds = Standard_False;
738   //
739   for (i = 2; i < n; ++i) {
740     aS = DBRep::Get(a[i]);
741     if (!aS.IsNull()) {
742       aLS.Append(aS);
743     }
744     else {
745       if (!strcmp(a[i], "-c")) {
746         bCompounds = Standard_True;
747       }
748       else if (!strcmp(a[i], "-ni")) {
749         bToIntersect = Standard_False;
750       }
751     }
752   }
753   //
754   if (aLS.IsEmpty()) {
755     di << "No shapes to process.\n";
756     di << usage;
757     return 1;
758   }
759   //
760   // treat list of arguments for the case of compounds
761   if (bToIntersect && bCompounds) {
762     BOPCol_ListOfShape aLSx;
763     BOPCol_ListIteratorOfListOfShape aItLS;
764     //
765     aItLS.Initialize(aLS);
766     for (; aItLS.More(); aItLS.Next()) {
767       const TopoDS_Shape& aSx = aItLS.Value();
768       TopoDS_Iterator aItS(aSx);
769       for (; aItS.More(); aItS.Next()) {
770         const TopoDS_Shape& aSxS = aItS.Value();
771         aLSx.Append(aSxS);
772       }
773     }
774     //
775     aLS.Clear();
776     aLS.Assign(aLSx);
777   }
778   //
779   BOPAlgo_MakerVolume aMV;
780   aMV.SetArguments(aLS);
781   aMV.SetIntersect(bToIntersect);
782   aMV.SetRunParallel(bRunParallel);
783   aMV.SetFuzzyValue(aTol);
784   //
785   aMV.Perform();
786   if (aMV.ErrorStatus()) {
787     di << "Error status: " << aMV.ErrorStatus();
788     return 1;
789   }
790   //
791   const TopoDS_Shape& aR = aMV.Shape();
792   //
793   DBRep::Set(a[1], aR);
794   //
795   return 0;
796 }