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