0028599: Replacement of old Boolean operations with new ones in BRepProj_Projection...
[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 <BOPDS_DS.hxx>
23 #include <BOPTest.hxx>
24 #include <BOPTest_Objects.hxx>
25 #include <BRep_Builder.hxx>
26 #include <BRepAlgoAPI_BooleanOperation.hxx>
27 #include <BRepAlgoAPI_Common.hxx>
28 #include <BRepAlgoAPI_Cut.hxx>
29 #include <BRepAlgoAPI_Fuse.hxx>
30 #include <BRepAlgoAPI_Section.hxx>
31 #include <DBRep.hxx>
32 #include <Draw.hxx>
33 #include <DrawTrSurf.hxx>
34 #include <Geom2d_Curve.hxx>
35 #include <Geom_Curve.hxx>
36 #include <IntTools_Curve.hxx>
37 #include <IntTools_FaceFace.hxx>
38 #include <IntTools_PntOn2Faces.hxx>
39 #include <NCollection_BaseAllocator.hxx>
40 #include <TCollection_AsciiString.hxx>
41 #include <TopoDS_Compound.hxx>
42 #include <TopoDS_Iterator.hxx>
43 #include <TopoDS_Shape.hxx>
44 #include <TopTools_ListOfShape.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                                "Builds section between shapes. Options:\n"
106                                "-n2d/-n2d1/-n2d2 - disable the PCurve construction;\n"
107                                "-na - disables the approximation of the section curves.\n",
108                                                       __FILE__, bsection, g);
109   //
110   theCommands.Add("bopcurves", "use bopcurves F1 F2 [-2d/-2d1/-2d2] "
111                                "[-p u1 v1 u2 v2 (to add start points] [-v (for extended output)]",
112                                                       __FILE__, bopcurves, g);
113   theCommands.Add("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-c] [-ni] [-ai]",
114                   __FILE__, mkvolume , g);
115 }
116
117 //=======================================================================
118 //function : bop
119 //purpose  : 
120 //=======================================================================
121 Standard_Integer bop(Draw_Interpretor& di, 
122                      Standard_Integer n, 
123                      const char** a)
124 {
125   Standard_Boolean bRunParallel, bNonDestructive;
126   Standard_Real aTol;
127   TopoDS_Shape aS1, aS2;
128   TopTools_ListOfShape aLC;
129   //
130   if (n != 3) {
131     di << " use bop s1 s2 \n";
132     return 0;
133   }
134   //
135   aS1=DBRep::Get(a[1]);
136   aS2=DBRep::Get(a[2]);
137   //
138   if (aS1.IsNull() || aS2.IsNull()) {
139     di << " null shapes are not allowed \n";
140     return 0;
141   }
142   //
143   aTol=BOPTest_Objects::FuzzyValue();
144   bRunParallel=BOPTest_Objects::RunParallel();
145   bNonDestructive = BOPTest_Objects::NonDestructive();
146   BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
147   //
148   aLC.Append(aS1);
149   aLC.Append(aS2);
150   //
151   if (pPF!=NULL) {
152     delete pPF;
153     pPF=NULL;
154   }
155   Handle(NCollection_BaseAllocator)aAL=
156     NCollection_BaseAllocator::CommonBaseAllocator();
157   pPF=new BOPAlgo_PaveFiller(aAL);
158   //
159   pPF->SetArguments(aLC);
160   pPF->SetFuzzyValue(aTol);
161   pPF->SetRunParallel(bRunParallel);
162   pPF->SetNonDestructive(bNonDestructive);
163   pPF->SetGlue(aGlue);
164   pPF->SetUseOBB(BOPTest_Objects::UseOBB());
165   //
166   pPF->Perform();
167   BOPTest::ReportAlerts(*pPF);
168   //
169   return 0;
170 }
171 //=======================================================================
172 //function : bopcommon
173 //purpose  : 
174 //=======================================================================
175 Standard_Integer bopcommon (Draw_Interpretor& di, 
176                             Standard_Integer n, 
177                             const char** a)
178 {
179   return bopsmt(di, n, a, BOPAlgo_COMMON);
180 }
181 //=======================================================================
182 //function : bopfuse
183 //purpose  : 
184 //=======================================================================
185 Standard_Integer bopfuse(Draw_Interpretor& di, 
186                          Standard_Integer n, 
187                          const char** a)
188 {
189   return bopsmt(di, n, a, BOPAlgo_FUSE);
190 }
191 //=======================================================================
192 //function : bopcut
193 //purpose  : 
194 //=======================================================================
195 Standard_Integer bopcut(Draw_Interpretor& di, 
196                         Standard_Integer n, 
197                         const char** a)
198 {
199   return bopsmt(di, n, a, BOPAlgo_CUT);
200 }
201 //=======================================================================
202 //function : boptuc
203 //purpose  : 
204 //=======================================================================
205 Standard_Integer boptuc(Draw_Interpretor& di, 
206                         Standard_Integer n, 
207                         const char** a)
208 {
209   return bopsmt(di, n, a, BOPAlgo_CUT21);
210 }
211 //=======================================================================
212 //function : bopsmt
213 //purpose  : 
214 //=======================================================================
215 Standard_Integer bopsmt(Draw_Interpretor& di,
216                         Standard_Integer n,
217                         const char** a,
218                         const BOPAlgo_Operation aOp)
219 {
220   if (n<2) {
221     di << " use bopsmt r\n";
222     return 0;
223   }
224   //
225   if (!pPF) {
226     di << " prepare PaveFiller first\n";
227     return 0;
228   }
229   //
230   if (pPF->HasErrors()) {
231     di << " PaveFiller has not been done\n";
232     return 0;
233   }
234   //
235   char buf[64];
236   Standard_Boolean bRunParallel;
237   Standard_Integer aNb;
238   BOPAlgo_BOP aBOP;
239   //
240   const TopTools_ListOfShape& aLC=pPF->Arguments();
241   aNb=aLC.Extent();
242   if (aNb!=2) {
243     Sprintf (buf, " wrong number of arguments %s\n", aNb);
244     di << buf;
245     return 0;
246   }
247   // 
248   bRunParallel=BOPTest_Objects::RunParallel();
249   //
250   const TopoDS_Shape& aS1=aLC.First();
251   const TopoDS_Shape& aS2=aLC.Last();
252   //
253   aBOP.AddArgument(aS1);
254   aBOP.AddTool(aS2);
255   aBOP.SetOperation(aOp);
256   aBOP.SetRunParallel (bRunParallel);
257   aBOP.SetCheckInverted(BOPTest_Objects::CheckInverted());
258   //
259   aBOP.PerformWithFiller(*pPF);
260   BOPTest::ReportAlerts(aBOP);
261   if (aBOP.HasErrors()) {
262     return 0;
263   }
264   //
265   const TopoDS_Shape& aR=aBOP.Shape();
266   if (aR.IsNull()) {
267     di << " null shape\n";
268     return 0;
269   }
270   //
271   DBRep::Set(a[1], aR);
272   return 0;
273 }
274 //=======================================================================
275 //function : bopsection
276 //purpose  : 
277 //=======================================================================
278 Standard_Integer bopsection(Draw_Interpretor& di, 
279                             Standard_Integer n, 
280                             const char** a)
281 {
282   if (n<2) {
283     di << " use bopsection r\n";
284     return 0;
285   }
286   //
287   if (!pPF) {
288     di << " prepare PaveFiller first\n";
289     return 0;
290   }
291   //
292   if (pPF->HasErrors()) {
293     di << " PaveFiller has not been done\n";
294     return 0;
295   }
296   //
297   char buf[64];
298   Standard_Boolean bRunParallel;
299   Standard_Integer aNb;
300   BOPAlgo_Section aBOP;
301   //
302   const TopTools_ListOfShape& aLC=pPF->Arguments();
303   aNb=aLC.Extent();
304   if (aNb!=2) {
305     Sprintf (buf, " wrong number of arguments %s\n", aNb);
306     di << buf;
307     return 0;
308   }
309   //
310   bRunParallel=BOPTest_Objects::RunParallel();
311   //
312   const TopoDS_Shape& aS1=aLC.First();
313   const TopoDS_Shape& aS2=aLC.Last();
314   //
315   aBOP.AddArgument(aS1);
316   aBOP.AddArgument(aS2);
317   aBOP.SetRunParallel (bRunParallel);
318   aBOP.SetCheckInverted(BOPTest_Objects::CheckInverted());
319   //
320   aBOP.PerformWithFiller(*pPF);
321   BOPTest::ReportAlerts(aBOP);
322   if (aBOP.HasErrors()) {
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   Standard_Boolean bRunParallel, bNonDestructive, bApp, bPC1, bPC2;
398   Standard_Real aTol;
399   //
400   bApp = Standard_True;
401   bPC1 = Standard_True;
402   bPC2 = Standard_True;
403   aTol = BOPTest_Objects::FuzzyValue(); 
404   bRunParallel = BOPTest_Objects::RunParallel();
405   bNonDestructive = BOPTest_Objects::NonDestructive();
406   BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
407   //
408   for (Standard_Integer 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   aSec.SetNonDestructive(bNonDestructive);
433   aSec.SetGlue(aGlue);
434   aSec.SetUseOBB(BOPTest_Objects::UseOBB());
435   //
436   aSec.Build();
437   //
438   if (aSec.HasWarnings()) {
439     Standard_SStream aSStream;
440     aSec.DumpWarnings(aSStream);
441     di << aSStream;
442   }
443   //
444   if (!aSec.IsDone()) {
445     Standard_SStream aSStream;
446     aSec.DumpErrors(aSStream);
447     di << aSStream;
448     return 0;
449   }
450   //
451   const TopoDS_Shape& aR=aSec.Shape();
452   if (aR.IsNull()) {
453     di << " null shape\n";
454     return 0;
455   }
456   DBRep::Set(a[1], aR);
457   return 0;
458 }
459 //=======================================================================
460 //function : bsmt
461 //purpose  : 
462 //=======================================================================
463 Standard_Integer bsmt (Draw_Interpretor& di, 
464                        Standard_Integer n, 
465                        const char** a,
466                        const BOPAlgo_Operation aOp)
467 {
468   Standard_Boolean bRunParallel, bNonDestructive;
469   TopoDS_Shape aS1, aS2;
470   TopTools_ListOfShape aLC;
471   Standard_Real aTol;
472   //
473   if (n != 4) {
474     di << " use bx r s1 s2\n";
475     return 0;
476   }
477   //
478   aS1=DBRep::Get(a[2]);
479   aS2=DBRep::Get(a[3]);
480   //
481   if (aS1.IsNull() || aS2.IsNull()) {
482     di << " null shapes are not allowed \n";
483     return 0;
484   }
485   aLC.Append(aS1);
486   aLC.Append(aS2);
487   // 
488   aTol=BOPTest_Objects::FuzzyValue();
489   bRunParallel = BOPTest_Objects::RunParallel();
490   bNonDestructive = BOPTest_Objects::NonDestructive();
491   BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
492   //
493   Handle(NCollection_BaseAllocator)aAL=
494     NCollection_BaseAllocator::CommonBaseAllocator();
495   //
496   //---------------------------------------------------------------
497   BOPAlgo_PaveFiller aPF(aAL);
498   //
499   aPF.SetArguments(aLC);
500   aPF.SetFuzzyValue(aTol); 
501   aPF.SetRunParallel(bRunParallel);
502   aPF.SetNonDestructive(bNonDestructive);
503   aPF.SetGlue(aGlue);
504   aPF.SetUseOBB(BOPTest_Objects::UseOBB());
505   //
506   aPF.Perform();
507   BOPTest::ReportAlerts(aPF);
508   if (aPF.HasErrors()) {
509     return 0;
510   }
511   //
512   //---------------------------------------------------------------
513   BOPAlgo_BOP aBOP(aAL);
514   //
515   aBOP.AddArgument(aS1);
516   aBOP.AddTool(aS2);
517   aBOP.SetOperation(aOp);
518   aBOP.SetRunParallel(bRunParallel);
519   aBOP.SetCheckInverted(BOPTest_Objects::CheckInverted());
520   // 
521   aBOP.PerformWithFiller(aPF);
522   BOPTest::ReportAlerts(aBOP);
523   if (aBOP.HasErrors()) {
524     return 0;
525   }
526   const TopoDS_Shape& aR=aBOP.Shape();
527   if (aR.IsNull()) {
528     di << " null shape\n";
529     return 0;
530   }
531   //
532   DBRep::Set(a[1], aR);
533   return 0;
534 }
535 //=======================================================================
536 //function : bopcurves
537 //purpose  : 
538 //=======================================================================
539 Standard_Integer bopcurves (Draw_Interpretor& di, 
540                             Standard_Integer n, 
541                             const char** a)
542 {
543   if (n<3) {
544     di << "Usage: bopcurves F1 F2 [-2d/-2d1/-2d2] "
545           "[-p u1 v1 u2 v2 (to add start points] [-v (for extended output)]\n";
546     return 1;
547   }
548   //
549   TopoDS_Shape S1 = DBRep::Get(a[1]);
550   TopoDS_Shape S2 = DBRep::Get(a[2]);
551   TopAbs_ShapeEnum aType;
552   //
553   if (S1.IsNull() || S2.IsNull()) {
554     di << " Null shapes are not allowed \n";
555     return 1;
556   }
557   //
558   aType=S1.ShapeType();
559   if (aType != TopAbs_FACE) {
560     di << " Type mismatch F1\n";
561     return 1;
562   }
563   aType=S2.ShapeType();
564   if (aType != TopAbs_FACE) {
565     di << " Type mismatch F2\n";
566     return 1;
567   }
568   //
569   const TopoDS_Face& aF1=*(TopoDS_Face*)(&S1);
570   const TopoDS_Face& aF2=*(TopoDS_Face*)(&S2);
571   //
572   Standard_Boolean aToApproxC3d, aToApproxC2dOnS1, aToApproxC2dOnS2, anIsDone;
573   Standard_Integer aNbCurves, aNbPoints;
574   Standard_Real anAppTol;
575   IntSurf_ListOfPntOn2S aListOfPnts;
576   TCollection_AsciiString aNm("c_"), aNp("p_");
577   //
578   anAppTol = 0.0000001;
579   aToApproxC3d = Standard_True;
580   aToApproxC2dOnS1 = Standard_False;
581   aToApproxC2dOnS2 = Standard_False;
582
583   //
584   Standard_Boolean bExtOut = Standard_False;
585   for(Standard_Integer i = 3; i < n; i++)
586   {
587     if (!strcasecmp(a[i],"-2d")) {
588       aToApproxC2dOnS1 = Standard_True;
589       aToApproxC2dOnS2 = Standard_True;
590     } 
591     else if (!strcasecmp(a[i],"-2d1")) {
592       aToApproxC2dOnS1 = Standard_True;
593     }
594     else if (!strcasecmp(a[i],"-2d2")) {
595       aToApproxC2dOnS2 = Standard_True;
596     }
597     else if (!strcasecmp(a[i],"-p")) {
598       IntSurf_PntOn2S aPt;
599       const Standard_Real aU1 = Draw::Atof(a[++i]);
600       const Standard_Real aV1 = Draw::Atof(a[++i]);
601       const Standard_Real aU2 = Draw::Atof(a[++i]);
602       const Standard_Real aV2 = Draw::Atof(a[++i]);
603
604       aPt.SetValue(aU1, aV1, aU2, aV2);
605       aListOfPnts.Append(aPt);
606     }
607     else if (!strcasecmp(a[i],"-v")) {
608       bExtOut = Standard_True;
609     }
610     else {
611       di << "Wrong key.\n";
612       di << "To build 2d curves use one of the following keys: -2d/-2d1/-2d2\n";
613       di << "To add start points use the following key: -p u1 v1 u2 v2\n";
614       di << "For extended output use the following key: -v\n";
615       return 1;
616     }
617   }
618   //
619   IntTools_FaceFace aFF;
620   //
621   aFF.SetParameters (aToApproxC3d,
622                      aToApproxC2dOnS1,
623                      aToApproxC2dOnS2,
624                      anAppTol);
625   aFF.SetList(aListOfPnts);
626   //
627   aFF.Perform (aF1, aF2);
628   //
629   anIsDone=aFF.IsDone();
630   if (!anIsDone) {
631     di << "Error: Intersection failed\n";
632     return 0;
633   }
634   //
635   aFF.PrepareLines3D(Standard_False);
636   const IntTools_SequenceOfCurves& aSCs=aFF.Lines();
637   const IntTools_SequenceOfPntOn2Faces& aSPs = aFF.Points();
638   //
639   aNbCurves = aSCs.Length();
640   aNbPoints = aSPs.Length();
641   if (!aNbCurves && !aNbPoints) {
642     di << " has no 3d curves\n";
643     di << " has no 3d points\n";
644     return 0;
645   }
646   //
647   // curves
648   if (aNbCurves) {
649     Standard_Real aTolR = 0.;
650     if (!bExtOut) {
651       // find maximal tolerance
652       for (Standard_Integer i = 1; i <= aNbCurves; i++) {
653         const IntTools_Curve& anIC = aSCs(i);
654         if (aTolR < anIC.Tolerance()) {
655           aTolR = anIC.Tolerance();
656         }
657       }
658       di << "Tolerance Reached=" << aTolR << "\n";
659     }
660     //
661     di << aNbCurves << " curve(s) found.\n";
662     //
663     for (Standard_Integer i=1; i<=aNbCurves; i++) {
664       const IntTools_Curve& anIC=aSCs(i);
665
666       Handle (Geom_Curve)  aC3D = anIC.Curve();
667
668       if (aC3D.IsNull()) {
669         di << " has Null 3d curve# " << i << "\n";
670         continue;
671       }
672
673       TCollection_AsciiString anIndx(i), aNmx;
674       aNmx = aNm + anIndx;
675
676       Standard_CString nameC = aNmx.ToCString();
677
678       DrawTrSurf::Set(nameC, aC3D);
679       di << nameC << " ";
680       //
681       Handle(Geom2d_Curve) aPC1 = anIC.FirstCurve2d();
682       Handle(Geom2d_Curve) aPC2 = anIC.SecondCurve2d();
683       //
684       if (!aPC1.IsNull() || !aPC2.IsNull()) {
685         di << "(";
686         //
687         if (!aPC1.IsNull()) {
688           TCollection_AsciiString pc1N("c2d1_"), pc1Nx;
689           pc1Nx = pc1N + anIndx;
690           Standard_CString nameC2d1 = pc1Nx.ToCString();
691           //
692           DrawTrSurf::Set(nameC2d1, aPC1);
693           di << nameC2d1;
694         }
695         //
696         if (!aPC2.IsNull()) {
697           TCollection_AsciiString pc2N("c2d2_"), pc2Nx;
698           pc2Nx = pc2N + anIndx;
699           Standard_CString nameC2d2 = pc2Nx.ToCString();
700           //
701           DrawTrSurf::Set(nameC2d2, aPC2);
702           //
703           if (!aPC1.IsNull()) {
704             di << ", ";
705           }
706           di << nameC2d2;
707         }
708         di << ") ";
709       }
710       //
711       if (bExtOut) {
712         di << "\nTolerance: " << anIC.Tolerance() << "\n";
713         di << "Tangential tolerance: " << anIC.TangentialTolerance() << "\n";
714         di << "\n";
715       }
716     }
717     if (!bExtOut) {
718       di << "\n";
719     }
720   }
721   //
722   // points
723   if (aNbPoints) {
724     di << aNbPoints << " point(s) found.\n";
725     //
726     for (Standard_Integer i = 1; i <= aNbPoints; i++) {
727       const IntTools_PntOn2Faces& aPi = aSPs(i);
728       const gp_Pnt& aP = aPi.P1().Pnt();
729       //
730       TCollection_AsciiString anIndx(i), aNmx;
731       aNmx = aNp + anIndx;
732       Standard_CString nameP = aNmx.ToCString();
733       //
734       DrawTrSurf::Set(nameP, aP);
735       di << nameP << " ";
736     }
737     di << "\n";
738   }
739   //
740   return 0;
741 }
742 //=======================================================================
743 //function : mkvolume
744 //purpose  : 
745 //=======================================================================
746 Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char** a) 
747 {
748   if (n < 3) {
749     di << "Usage: mkvolume r b1 b2 ... [-c] [-ni] [-ai]\n";
750     di << "Options:\n";
751     di << " -c  - use this option if the arguments are compounds\n";
752     di << "       containing shapes that should be interfered;\n";
753     di << " -ni - use this option if the arguments should not be interfered;\n";
754     di << " -ai - use this option to avoid internal for solids shapes in the result.\n";
755     return 1;
756   }
757   //
758   const char* usage = "Type mkvolume without arguments for the usage of the command.\n";
759   //
760   Standard_Boolean bToIntersect, bRunParallel, bNonDestructive;
761   Standard_Boolean bCompounds, bAvoidInternal;
762   Standard_Integer i;
763   Standard_Real aTol;
764   TopoDS_Shape aS;
765   TopTools_ListOfShape aLS;
766   //
767   aTol = BOPTest_Objects::FuzzyValue();
768   bRunParallel = BOPTest_Objects::RunParallel();
769   bNonDestructive = BOPTest_Objects::NonDestructive();
770   BOPAlgo_GlueEnum aGlue = BOPTest_Objects::Glue();
771   //
772   bToIntersect = Standard_True;
773   bCompounds = Standard_False;
774   bAvoidInternal = Standard_False;
775   //
776   for (i = 2; i < n; ++i) {
777     aS = DBRep::Get(a[i]);
778     if (!aS.IsNull()) {
779       aLS.Append(aS);
780     }
781     else {
782       if (!strcmp(a[i], "-c")) {
783         bCompounds = Standard_True;
784       }
785       else if (!strcmp(a[i], "-ni")) {
786         bToIntersect = Standard_False;
787       }
788       else if (!strcmp(a[i], "-ai")) {
789         bAvoidInternal = Standard_True;
790       }
791     }
792   }
793   //
794   if (aLS.IsEmpty()) {
795     di << "No shapes to process.\n";
796     di << usage;
797     return 1;
798   }
799   //
800   // treat list of arguments for the case of compounds
801   if (bToIntersect && bCompounds) {
802     TopTools_ListOfShape aLSx;
803     TopTools_ListIteratorOfListOfShape aItLS;
804     //
805     aItLS.Initialize(aLS);
806     for (; aItLS.More(); aItLS.Next()) {
807       const TopoDS_Shape& aSx = aItLS.Value();
808       TopoDS_Iterator aItS(aSx);
809       for (; aItS.More(); aItS.Next()) {
810         const TopoDS_Shape& aSxS = aItS.Value();
811         aLSx.Append(aSxS);
812       }
813     }
814     //
815     aLS.Clear();
816     aLS.Assign(aLSx);
817   }
818   //
819   BOPAlgo_MakerVolume aMV;
820   aMV.SetArguments(aLS);
821   aMV.SetIntersect(bToIntersect);
822   aMV.SetRunParallel(bRunParallel);
823   aMV.SetFuzzyValue(aTol);
824   aMV.SetNonDestructive(bNonDestructive);
825   aMV.SetAvoidInternalShapes(bAvoidInternal);
826   aMV.SetGlue(aGlue);
827   aMV.SetUseOBB(BOPTest_Objects::UseOBB());
828   //
829   aMV.Perform();
830   BOPTest::ReportAlerts(aMV);
831   if (aMV.HasErrors()) {
832     return 0;
833   }
834   //
835   const TopoDS_Shape& aR = aMV.Shape();
836   //
837   DBRep::Set(a[1], aR);
838   //
839   return 0;
840 }