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