0023024: Update headers of OCCT files
[occt.git] / src / BOPTest / BOPTest_BOPCommands.cxx
1 // Created on: 2000-03-16
2 // Created by: Peter KURNEV
3 // Copyright (c) 2000-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20
21
22 #include <BOPTest.ixx>
23
24 #include <stdio.h>
25
26 #include <DBRep.hxx>
27 #include <DBRep_DrawableShape.hxx>
28
29 #include <Draw.hxx>
30 #include <Draw_Color.hxx>
31
32 #include <TCollection_AsciiString.hxx>
33
34 #include <TopAbs_ShapeEnum.hxx>
35 #include <TopoDS.hxx>
36 #include <TopoDS_Shape.hxx>
37 #include <TopoDS_Shell.hxx>
38
39 #include <TopExp.hxx>
40 #include <TopTools_IndexedMapOfShape.hxx>
41
42 #include <BRep_Builder.hxx>
43
44 #include <BooleanOperations_ShapesDataStructure.hxx>
45 #include <BooleanOperations_StateOfShape.hxx>
46
47 #include <BOPTools_SolidStateFiller.hxx>
48 #include <BOPTools_DSFiller.hxx>
49 #include <BOPTools_SplitShapesPool.hxx>
50 #include <BOPTools_ListOfPaveBlock.hxx>
51 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
52 #include <BOPTools_PaveBlock.hxx>
53 #include <BOPTools_PCurveMaker.hxx>
54 #include <BOPTools_InterferencePool.hxx>
55 #include <BOPTools_CArray1OfVVInterference.hxx>
56 #include <BOPTools_CArray1OfVSInterference.hxx>
57 #include <BOPTools_CArray1OfVEInterference.hxx>
58 #include <BOPTools_CArray1OfESInterference.hxx>
59 #include <BOPTools_CArray1OfEEInterference.hxx>
60 #include <BOPTools_CArray1OfSSInterference.hxx>
61 #include <BOPTools_VVInterference.hxx>
62 #include <BOPTools_VEInterference.hxx>
63 #include <BOPTools_VSInterference.hxx>
64 #include <BOPTools_EEInterference.hxx>
65 #include <BOPTools_ESInterference.hxx>
66 #include <BOPTools_SSInterference.hxx>
67
68 #include <BOPTest_DrawableShape.hxx>
69
70 #include <BRepAlgoAPI_BooleanOperation.hxx>
71 #include <BRepAlgoAPI_Section.hxx>
72 #include <BRepAlgoAPI_Common.hxx>
73 #include <BRepAlgoAPI_Fuse.hxx>
74 #include <BRepAlgoAPI_Cut.hxx>
75
76 #include <OSD_Chronometer.hxx>
77 #include <TColStd_IndexedMapOfInteger.hxx>
78
79 static OSD_Chronometer DRAW_BOP_CHRONO;
80 static void StartChrono();
81 static void StopChrono(Draw_Interpretor&); 
82 Standard_Integer btimesum (Draw_Interpretor& , Standard_Integer n, const char** a);
83 //XX
84
85 //
86 static   Standard_Integer bop        (Draw_Interpretor&,   Standard_Integer,   const char**);
87 //
88 static   Standard_Integer bcommon    (Draw_Interpretor& ,  Standard_Integer ,  const char**);
89 static   Standard_Integer bfuse      (Draw_Interpretor& ,  Standard_Integer ,  const char**);
90 static   Standard_Integer bcut       (Draw_Interpretor& ,  Standard_Integer ,  const char**);
91 static   Standard_Integer bsection   (Draw_Interpretor& ,  Standard_Integer ,  const char**);
92
93 static   Standard_Integer bFillDS    (Draw_Interpretor& ,  Standard_Integer  , const char**);
94 //
95 static   Standard_Integer bopcommon  (Draw_Interpretor& ,  Standard_Integer ,  const char**);
96 static   Standard_Integer bopfuse    (Draw_Interpretor& ,  Standard_Integer ,  const char**);
97 static   Standard_Integer bopcut     (Draw_Interpretor& ,  Standard_Integer ,  const char**);
98 static   Standard_Integer boptuc     (Draw_Interpretor& ,  Standard_Integer ,  const char**);
99 static   Standard_Integer bopsection (Draw_Interpretor& ,  Standard_Integer ,  const char**);
100
101 static   Standard_Integer boperationFiller (Standard_Integer n, const char** a, const BOP_Operation anOp,
102                                             Draw_Interpretor&);
103 //
104 static   Standard_Integer bopstates  (Draw_Interpretor& ,  Standard_Integer ,  const char**);
105 //
106 static  Standard_Integer bopwho      (Draw_Interpretor& ,  Standard_Integer ,  const char**);
107 static  Standard_Integer bopsticks   (Draw_Interpretor& ,  Standard_Integer ,  const char**);
108
109
110 static
111   void UnUsedMap(BOPTools_SequenceOfCurves& ,
112                  const BOPTools_PaveSet& ,
113                  TColStd_IndexedMapOfInteger& );
114 //=======================================================================
115 //function : BOPCommands
116 //purpose  : 
117 //=======================================================================
118   void  BOPTest::BOPCommands(Draw_Interpretor& theCommands)
119 {
120   static Standard_Boolean done = Standard_False;
121   if (done) 
122     return;
123
124   done = Standard_True;
125   // Chapter's name
126   const char* g = "CCR commands";
127   //
128   // Using DSFiller that is ready.
129   theCommands.Add("bop"       , "Use  >bop Shape1 Shape2", __FILE__,   bop, g);
130   theCommands.Add("bopcommon" , "Use  >bopcommon R" , __FILE__, bopcommon , g);
131   theCommands.Add("bopfuse"   , "Use  >bopfuse R"   , __FILE__, bopfuse   , g);
132   theCommands.Add("bopcut"    , "Use  >bopcut R"    , __FILE__, bopcut    , g);
133   theCommands.Add("boptuc"    , "Use  >boptuc R"    , __FILE__, boptuc    , g);
134   theCommands.Add("bopsection", "Use  >bopsection R", __FILE__, bopsection, g);
135   //
136   // States
137   theCommands.Add("bopstates",  "Use  bopstates [-f] [-t] [-out]", __FILE__, bopstates, g);
138   //
139   theCommands.Add("bcommon" , "Use >bcommon R a b"    , __FILE__, bcommon , g);
140   theCommands.Add("bfuse"   , "Use >bfuse  R a b"     , __FILE__, bfuse   , g);
141   theCommands.Add("bcut"    , "Use >bcut R a b"       , __FILE__, bcut    , g);
142   // 
143   //  bsection
144   theCommands.Add("bsection", "Use >bsection Result s1 s2 [-2d/-2d1/-2d2] [-a]"  
145                   , __FILE__, bsection, g);
146   //
147   theCommands.Add("btimesum"   , "Use >btimesum FileName"   , __FILE__, btimesum,  g);
148   theCommands.Add("bopwho"     , "Use >bopwho Index"        , __FILE__, bopwho,    g);
149   theCommands.Add("bopsticks"  , "Use >bopsticks"           , __FILE__, bopsticks, g);
150   //
151 }
152 //
153 //////////////////////////////////
154 //
155 // The one and only global variable
156 //
157 BOPTools_DSFiller *pDF;
158 //
159 //////////////////////////////////
160 //
161 //=======================================================================
162 //function : bop
163 //purpose  : 
164 //=======================================================================
165 Standard_Integer bop (Draw_Interpretor& di, 
166                       Standard_Integer n, 
167                       const char** a)
168 {
169   StartChrono();
170
171   if (n<3) {
172     di << " Use >bop Shape1 Shape2\n";
173     StopChrono(di);
174     return 1;
175   }
176
177   TopoDS_Shape S1 = DBRep::Get(a[1]);
178   TopoDS_Shape S2 = DBRep::Get(a[2]);
179   
180   if (S1.IsNull() || S2.IsNull()) {
181     di << " Null shapes are not allowed \n";
182     StopChrono(di);
183     return 1;
184   }
185   if (pDF!=NULL) {
186     delete pDF;
187     pDF=NULL;
188   }
189
190   pDF=new BOPTools_DSFiller;
191   
192   pDF->SetShapes (S1, S2);
193   if (!pDF->IsDone()) {
194     di << "Check types of the arguments, please\n";
195     if (pDF!=NULL) {
196       delete pDF;
197       pDF=NULL;
198     }
199     StopChrono(di);
200     return 1;
201   }
202   
203   pDF->Perform();
204   //printf(" BOPTools_DSFiller is Ready to use\n");
205  
206   StopChrono(di);
207   
208   return 0;
209 }
210
211 //=======================================================================
212 //function : bFillDS
213 //purpose  : 
214 //=======================================================================
215 Standard_Integer bFillDS (Draw_Interpretor& di, 
216                           Standard_Integer n, 
217                           const char** a)
218 {
219   if (n!=4) {
220     di << " Usage: >command  Result Shape1 Shape2\n";
221     return 1;
222   }
223   
224   return bop(di, n, a+1);
225 }
226
227 //=======================================================================
228 //function : bcommon
229 //purpose  : 
230 //=======================================================================
231 Standard_Integer bcommon (Draw_Interpretor& di, 
232                           Standard_Integer n, 
233                           const char** a)
234 {
235   Standard_Integer iFlag;
236
237   iFlag =bFillDS (di, n, a);
238
239   if (iFlag) {
240     return iFlag;
241   }
242
243   return bopcommon(di, n, a);
244 }
245 //=======================================================================
246 //function : bfuse
247 //purpose  : 
248 //=======================================================================
249 Standard_Integer  bfuse(Draw_Interpretor& di, 
250                         Standard_Integer n, 
251                         const char** a)
252 {
253   Standard_Integer iFlag;
254
255   iFlag =bFillDS (di, n, a);
256
257   if (iFlag) {
258     return iFlag;
259   }
260
261   return bopfuse(di, n, a);
262 }
263
264 //=======================================================================
265 //function : bcut
266 //purpose  : 
267 //=======================================================================
268 Standard_Integer  bcut(Draw_Interpretor& di, 
269                        Standard_Integer n, 
270                        const char** a)
271 {
272   Standard_Integer iFlag;
273
274   iFlag =bFillDS (di, n, a);
275
276   if (iFlag) {
277     return iFlag;
278   }
279
280   return bopcut(di, n, a);
281 }
282 //=======================================================================
283 //function : bsection
284 //purpose  : 
285 //=======================================================================
286 Standard_Integer  bsection(Draw_Interpretor& di, 
287                            Standard_Integer n, 
288                            const char** a)
289 {
290   const char* usage = " Usage: bsection Result s1 s2 [-2d/-2d1/-2d2] [-a]\n";
291   if (n < 4) {
292     di << usage;
293     return 1;
294   }
295
296   TopoDS_Shape S1 = DBRep::Get(a[2]);
297   TopoDS_Shape S2 = DBRep::Get(a[3]);
298   
299   if (S1.IsNull() || S2.IsNull()) {
300     di << " Null shapes are not allowed \n";
301     return 1;
302   }
303
304
305   BRepAlgoAPI_Section aSec(S1, S2, Standard_False);
306   aSec.Approximation(Standard_False);
307   aSec.ComputePCurveOn1(Standard_False);
308   aSec.ComputePCurveOn2(Standard_False);
309   Standard_Boolean isbadparameter = Standard_False;
310   
311   if(n > 4) {
312     const char* key1 = a[4];
313     const char* key2 = (n > 5) ? a[5] : NULL;
314     const char* pcurveconf = NULL;
315     Standard_Boolean approx = Standard_False;
316
317 #ifdef WNT
318     if (key1 && !strcasecmp(key1,"-2d")) {
319 #else 
320     if (key1 && !strncasecmp(key1,"-2d", 3)) {
321 #endif
322       pcurveconf = key1;
323     }
324     else {
325       if (!strcasecmp(key1,"-a")) {
326         approx = Standard_True;
327       }
328       else {
329         isbadparameter = Standard_True;
330       }
331     }
332 #ifdef WNT
333     if (key2 && !strcasecmp(key2,"-2d")) {
334 #else 
335     if (key2 && !strncasecmp(key2,"-2d", 3)) {
336 #endif
337       if(pcurveconf) {
338         isbadparameter = Standard_True;
339       }
340       else {
341         pcurveconf = key2;
342       }
343     }
344     else {
345       if(key2) {
346         if (!strcasecmp(key2,"-a")) {
347           approx = Standard_True;
348         }
349         else {
350           isbadparameter = Standard_True;
351         }
352       }
353     }
354     
355     if(!isbadparameter && pcurveconf) {      
356
357       if (strcasecmp(pcurveconf, "-2d") == 0) {
358         aSec.ComputePCurveOn1(Standard_True);
359         aSec.ComputePCurveOn2(Standard_True);
360       }
361       else {
362         if (strcasecmp(pcurveconf, "-2d1") == 0) {
363           aSec.ComputePCurveOn1(Standard_True);
364         }
365         else {
366           if (strcasecmp(pcurveconf, "-2d2") == 0) {
367             aSec.ComputePCurveOn2(Standard_True);
368           }
369         }
370       }
371     }
372     aSec.Approximation(approx);
373   }
374       
375   if(!isbadparameter) { 
376     aSec.Build();
377     Standard_Boolean anIsDone = aSec.IsDone();
378
379     if (anIsDone) {
380       const TopoDS_Shape& aR = aSec.Shape();
381       DBRep::Set (a[1], aR);
382     }
383     else {
384       di << "not done ErrorStatus()="<< aSec.ErrorStatus() <<"\n";
385     }
386   }
387   else {
388     di << usage;
389     return 1;
390   }
391   return 0;
392 }
393
394 //=======================================================================
395 //function : bopcommon
396 //purpose  : 
397 //=======================================================================
398 Standard_Integer bopcommon (Draw_Interpretor& di, 
399                             Standard_Integer n, 
400                             const char** a)
401 {
402   return boperationFiller (n, a, BOP_COMMON, di); 
403 }
404
405 //=======================================================================
406 //function : bopfuse
407 //purpose  : 
408 //=======================================================================
409 Standard_Integer  bopfuse(Draw_Interpretor& di, 
410                             Standard_Integer n, 
411                             const char** a)
412 {
413   return boperationFiller (n, a, BOP_FUSE, di); 
414 }
415
416 //=======================================================================
417 //function : bopcut
418 //purpose  : 
419 //=======================================================================
420 Standard_Integer bopcut (Draw_Interpretor& di, 
421                          Standard_Integer n, 
422                          const char** a)
423 {
424   return boperationFiller (n, a, BOP_CUT, di); 
425 }
426 //=======================================================================
427 //function : boptuc
428 //purpose  : 
429 //=======================================================================
430 Standard_Integer boptuc (Draw_Interpretor& di, 
431                          Standard_Integer n, 
432                          const char** a)
433 {
434   return boperationFiller (n, a, BOP_CUT21, di); 
435 }
436 //=======================================================================
437 //function : bopsection
438 //purpose  : 
439 //=======================================================================
440 Standard_Integer bopsection (Draw_Interpretor& di, 
441                              Standard_Integer n, 
442                              const char** a)
443 {
444   return boperationFiller (n, a, BOP_SECTION, di); 
445 }
446
447 //=======================================================================
448 //function : boperationFiller
449 //purpose  : 
450 //=======================================================================
451 Standard_Integer boperationFiller (Standard_Integer n, 
452                                    const char** a,
453                                    const BOP_Operation anOp,
454                                    Draw_Interpretor& di)
455 {
456   //XX
457   StartChrono();
458   //XX
459
460   if (n<2) {
461     di << " Use oper> Result [-mf]\n";
462     StopChrono(di);
463     return 1;
464   }
465   
466   if (pDF==NULL) {
467     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
468     StopChrono(di);
469     return 1;
470   }
471
472   const TopoDS_Shape& S1 = pDF->Shape1();
473   const TopoDS_Shape& S2 = pDF->Shape2();
474
475   if (S1.IsNull() || S2.IsNull()) {
476     di << " Null shapes are not allowed \n";
477     StopChrono(di);
478     return 1;
479   }
480
481   Standard_Boolean aMFlag, anIsDone;
482
483   aMFlag=Standard_False;
484   //
485   BRepAlgoAPI_BooleanOperation* pBuilder=NULL;
486   // 
487   // SECTION
488   if (anOp==BOP_SECTION) {
489     pBuilder=new BRepAlgoAPI_Section(S1, S2, *pDF);
490   }
491   else if (anOp==BOP_COMMON) {
492     pBuilder=new BRepAlgoAPI_Common(S1, S2, *pDF);
493   }
494   else if (anOp==BOP_FUSE) {
495     pBuilder=new BRepAlgoAPI_Fuse(S1, S2, *pDF);
496   }
497   else if (anOp==BOP_CUT) {
498     pBuilder=new BRepAlgoAPI_Cut (S1, S2, *pDF);
499   }
500   else if (anOp==BOP_CUT21) {
501     pBuilder=new BRepAlgoAPI_Cut(S1, S2, *pDF, Standard_False);
502   }
503   //
504   anIsDone=pBuilder->IsDone();
505   if (anIsDone) {
506     const TopoDS_Shape& aR=pBuilder->Shape();
507     DBRep::Set (a[1], aR);
508   }
509   else {
510     di << "not done ErrorStatus()=" << pBuilder->ErrorStatus() << "\n";
511   }
512   
513   delete pBuilder;
514
515   StopChrono(di);
516
517   return 0;
518 }
519
520 //=======================================================================
521 // OTHER FUNCTIONS
522 //
523 static 
524   void GetName (const BooleanOperations_StateOfShape aState,
525                 TCollection_AsciiString& aNm);
526 static  
527   TopAbs_ShapeEnum ChooseShapeType(const char* a1);
528
529 static
530   BooleanOperations_StateOfShape ChooseShapeState(const char* a3);
531
532 //=======================================================================
533 //function : bopstates
534 //purpose  : 
535 //=======================================================================
536 Standard_Integer  bopstates(Draw_Interpretor& di, 
537                              Standard_Integer n, 
538                              const char** a)
539 {
540   if (n>4) {
541     di << " Use bopstates [-f] [-t] [-out]\n";
542     return 1;
543   }
544   
545   if (pDF==NULL) {
546     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
547     return 0;
548   }
549
550   Standard_Integer i, aNbLines, aIsSmtToDraw=0;
551   BooleanOperations_StateOfShape aState, aChooseState;
552   aChooseState=BooleanOperations_UNKNOWN;
553   TopAbs_ShapeEnum aEnumToDisplay = TopAbs_COMPOUND;
554   Draw_Color aTextColor(Draw_cyan);
555   //
556   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
557   //
558   // Choose Object or Tool or All
559   i=1;
560   aNbLines=aDS.NumberOfSourceShapes();
561   if (n>=3) {
562     if (!strcmp (a[2], "-o")) {
563       aDS.ObjectRange(i, aNbLines);
564     }
565     if (!strcmp (a[2], "-t")) {
566       aDS.ToolRange(i, aNbLines);
567     }
568   }
569   //
570   // ChooseShapeState
571   if (n==4) {
572     aChooseState=ChooseShapeState(a[3]);
573   }
574   //
575   // ChooseShapeType
576   if (n==1) {
577     aEnumToDisplay=TopAbs_EDGE;
578   }
579   else if (n>1) {
580     aEnumToDisplay=ChooseShapeType(a[1]);
581   }
582   //
583   // Presentation
584   for (; i<=aNbLines; ++i) {
585     const TopoDS_Shape& aS=aDS.GetShape(i);
586     TopAbs_ShapeEnum aCurrentType=aS.ShapeType();
587     if (aCurrentType==aEnumToDisplay) {
588       aState=aDS.GetState(i);
589       TCollection_AsciiString aNm, aInd(i);
590       GetName(aState, aNm);
591
592       if (aState==BooleanOperations_INTERSECTED && aCurrentType==TopAbs_EDGE) {
593         
594         const BOPTools_SplitShapesPool& aSpPool=pDF->SplitShapesPool();
595         const BOPTools_ListOfPaveBlock& aSplitsList=aSpPool(aDS.RefEdge(i));
596         BOPTools_ListIteratorOfListOfPaveBlock anIt(aSplitsList);
597         for (; anIt.More();anIt.Next()) {
598           const BOPTools_PaveBlock& aPB=anIt.Value();
599           Standard_Integer nSplit=aPB.Edge();
600           const TopoDS_Shape& aSplit=aDS.GetShape(nSplit);
601           aState=aDS.GetState(nSplit);
602           GetName(aState, aNm);
603           aNm=aNm+aInd;
604           TCollection_AsciiString aNmx, anUnd("_"), aIndx(nSplit);
605           aNmx=aNm+anUnd;
606           aNmx=aNmx+aIndx;
607           
608           Standard_CString aTxt=aNmx.ToCString();
609           
610           if (aChooseState!=BooleanOperations_UNKNOWN) {
611             if (aState!=aChooseState) {
612               continue;
613             }
614           }
615           aIsSmtToDraw++;
616           //printf("%s ",  aTxt);
617           di << aTxt << " ";
618           Handle(BOPTest_DrawableShape) aDSh=
619             new BOPTest_DrawableShape (aSplit, aTxt, aTextColor);
620           Draw::Set (aTxt, aDSh);
621         }
622           continue;
623       }
624
625       aNm=aNm+aInd;
626       Standard_CString aText=aNm.ToCString();
627       
628       if (aChooseState!=BooleanOperations_UNKNOWN) {
629         if (aState!=aChooseState) {
630           continue;
631         }
632       }
633       aIsSmtToDraw++;
634       //printf("%s ",  aText);
635       di << aText << " ";
636       Handle(BOPTest_DrawableShape) aDShape=
637         new BOPTest_DrawableShape (aS, aText, aTextColor);
638       Draw::Set (aText, aDShape);
639     }
640   }
641
642   if (!aIsSmtToDraw) {
643     di << " No specified shapes\n"; 
644   }
645   else {
646     di << "\n";
647   }
648
649
650   return 0;
651 }
652
653 //=======================================================================
654 //function : GetName
655 //purpose  : 
656 //=======================================================================
657 void GetName (const BooleanOperations_StateOfShape aState,
658               TCollection_AsciiString& aNm)
659 {
660   TCollection_AsciiString aNmOut("ou_"), aNmIn("in_"), 
661        aNmOn("on_"), aNmUn("un_"), aNmInter("intr_");
662
663   switch (aState) {
664     case BooleanOperations_OUT:
665       aNm=aNmOut;
666       break;
667     case  BooleanOperations_IN:
668       aNm=aNmIn; 
669       break;
670     case BooleanOperations_ON:
671       aNm=aNmOn;
672       break;
673     case BooleanOperations_INTERSECTED:
674       aNm=aNmInter;
675       break;
676     default:
677       aNm=aNmUn;
678       break;
679   }
680 }
681
682 //=======================================================================
683 //function : ChooseShapeType
684 //purpose  : 
685 //=======================================================================
686 TopAbs_ShapeEnum ChooseShapeType(const char* a1)
687 {
688   TopAbs_ShapeEnum aEnumToDisplay;
689
690   if (!strcmp (a1, "-c")) {
691     aEnumToDisplay=TopAbs_COMPOUND;
692   }
693   else if (!strcmp (a1, "-cs")) {
694     aEnumToDisplay=TopAbs_COMPSOLID;
695   }
696   else if (!strcmp (a1, "-s")) {
697     aEnumToDisplay=TopAbs_SOLID;
698   }
699   else if (!strcmp (a1, "-sh")) {
700     aEnumToDisplay=TopAbs_SHELL;
701   }
702   else if (!strcmp (a1, "-f")) {
703     aEnumToDisplay=TopAbs_FACE;
704   }
705   else if (!strcmp (a1, "-w")) {
706     aEnumToDisplay=TopAbs_WIRE;
707   }
708   else if (!strcmp (a1, "-e")) {
709     aEnumToDisplay=TopAbs_EDGE;
710   }
711   else if (!strcmp (a1, "-v")) {
712     aEnumToDisplay=TopAbs_VERTEX;
713   }
714   else {
715     aEnumToDisplay=TopAbs_EDGE;
716   }
717   return aEnumToDisplay;
718 }
719
720 //=======================================================================
721 //function : ChooseShapeState
722 //purpose  : 
723 //=======================================================================
724 BooleanOperations_StateOfShape ChooseShapeState(const char* a3)
725
726   BooleanOperations_StateOfShape aChooseState=BooleanOperations_UNKNOWN;
727
728   if (!strcmp (a3, "-out")) {
729     aChooseState=BooleanOperations_OUT;
730   }
731   if (!strcmp (a3, "-in")) {
732     aChooseState=BooleanOperations_IN;
733   }
734   if (!strcmp (a3, "-on")) {
735     aChooseState=BooleanOperations_ON;
736   }
737   return aChooseState;
738 }
739 //XX
740 // CHRONOMETER
741 //
742 #include <OSD_Chronometer.hxx>
743 #include <TCollection_AsciiString.hxx>
744 #include <OSD_OpenMode.hxx>
745 #include <OSD_Path.hxx>
746 #include <OSD_Protection.hxx>
747 #include <OSD_File.hxx>
748
749 static void SaveTimeInFile(const Standard_CString aFileName,
750                            const Standard_Real aChrono,
751                            Draw_Interpretor& di);
752
753 //=======================================================================
754 //function : StartChrono
755 //purpose  : 
756 //=======================================================================
757 void StartChrono() 
758 {
759   char *xr=getenv ("BOPCHRONO");
760   if (xr!=NULL){
761     if (!strcmp (xr, "yes")){
762       DRAW_BOP_CHRONO.Reset();
763       DRAW_BOP_CHRONO.Start();
764     }
765   }
766 }
767
768 //=======================================================================
769 //function : StopChrono
770 //purpose  : 
771 //=======================================================================
772 void StopChrono(Draw_Interpretor& di) 
773
774   char *xr=getenv ("BOPCHRONO");
775   if (xr!=NULL){
776     if (!strcmp (xr, "yes")) {
777       Standard_Real Chrono;
778       DRAW_BOP_CHRONO.Stop();
779       DRAW_BOP_CHRONO.Show(Chrono);
780       //
781       char *aFileName=getenv("BOPCHRONOFILE");
782       if (aFileName!=NULL){
783         SaveTimeInFile(aFileName, Chrono, di);
784       }
785       else {
786         di << "Tps: " << Chrono << "\n";
787       }
788       //
789     }
790   }
791 }
792 //=======================================================================
793 //function : SaveTimeInFile
794 //purpose  : 
795 //=======================================================================
796 void SaveTimeInFile(const Standard_CString aFileName,
797                     const Standard_Real aChrono,
798                     Draw_Interpretor& di)
799 {
800   OSD_OpenMode aMode =  OSD_ReadWrite;
801   OSD_Protection  aProtect(OSD_RW,OSD_RW,OSD_RW,OSD_RW);
802   TCollection_AsciiString anASName(aFileName);
803   OSD_Path aPath (anASName);
804   OSD_File aFile (aPath);
805   aFile.Append(aMode, aProtect);
806   if (!( aFile.Exists() && aFile.IsOpen())) { 
807     Standard_CString aStr=anASName.ToCString();
808     di << "Can not open the file: " << aStr << "\n";
809     return;
810   }
811   TCollection_AsciiString aASTime(aChrono), aASendl("\n");
812   aASTime=aASTime+aASendl;
813   aFile.Write (aASTime, aASTime.Length());
814   aFile.Close();
815 }
816 //XX
817 //=======================================================================
818 //function : btimesum
819 //purpose  : 
820 //=======================================================================
821 Standard_Integer btimesum (Draw_Interpretor& di, 
822                            Standard_Integer n, 
823                            const char** a)
824 {
825   if (n!=2) {
826     di << " Use >btimesum FileName\n";
827     return 1;
828   }
829    
830   TCollection_AsciiString anASName(a[1]);
831   OSD_OpenMode aMode =  OSD_ReadWrite;
832   OSD_Protection  aProtect(OSD_RW,OSD_RW,OSD_RW,OSD_RW);
833   OSD_Path aPath (anASName);
834   OSD_File aFile (aPath);
835   aFile.Open(aMode, aProtect);
836
837   if (!( aFile.Exists() && aFile.IsOpen())) { 
838     Standard_CString aStr=anASName.ToCString();
839     di << "Can not open the file: " << aStr << "\n";
840     return 1;
841   }
842
843   Standard_Integer aNbyteRead, aNByte=256, pos;
844   Standard_Real aTC, aTime=0.;
845   while (1) {
846     if (aFile.IsAtEnd()) {
847       break;
848     }
849     
850     TCollection_AsciiString aStr(aNByte);
851     aFile.ReadLine(aStr, aNByte, aNbyteRead);
852     //Standard_CString pStr=aStr.ToCString();
853
854     pos=aStr.Search("\n");
855     if (pos>0){
856       aStr.Trunc(pos-1);
857     }
858     
859     if (aStr.IsRealValue()) {
860       aTC=aStr.RealValue();
861       aTime=aTime+aTC;
862     }
863   }
864   aFile.Close();
865   //
866   aFile.Append(aMode, aProtect);
867
868   TCollection_AsciiString aASLine("----------\n"), aASTime(aTime), aASendl("\n");
869   aASTime=aASTime+aASendl;
870   aFile.Write (aASLine, aASLine.Length());
871   aFile.Write (aASTime, aASTime.Length());
872   aFile.Close();
873   
874   return 0;
875 }
876
877
878 //=======================================================================
879 //
880 //                         ex. BOPTest_TSTCommands
881 //
882 #include <stdio.h>
883
884 #include <BOPTest_DrawableShape.hxx>
885
886 #include <DBRep.hxx>
887 #include <DBRep_DrawableShape.hxx>
888
889 #include <Draw.hxx>
890 #include <Draw_Color.hxx>
891
892 #include <TCollection_AsciiString.hxx>
893
894 #include <TColStd_ListOfInteger.hxx>
895 #include <TColStd_ListIteratorOfListOfInteger.hxx>
896
897
898 #include <BooleanOperations_ShapesDataStructure.hxx>
899 #include <BOPTools_CArray1OfInterferenceLine.hxx>
900 #include <BOPTools_InterferenceLine.hxx>
901 #include <BOPTools_ListOfInterference.hxx>
902 #include <BOPTools_ListIteratorOfListOfInterference.hxx>
903 #include <BOPTools_Interference.hxx>
904 #include <BOPTools_InterferencePool.hxx>
905
906 #include <BOPTools_DSFiller.hxx>
907 #include <BOPTools_SplitShapesPool.hxx>
908 #include <BOPTools_ListOfPaveBlock.hxx>
909 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
910 #include <BOPTools_PaveBlock.hxx>
911
912 #include <BOPTools_PavePool.hxx>
913 #include <BOPTools_PaveSet.hxx>
914 #include <BOPTools_ListOfPave.hxx>
915 #include <BOPTools_ListIteratorOfListOfPave.hxx>
916
917 #include <BOPTools_CommonBlockPool.hxx>
918 #include <BOPTools_ListOfCommonBlock.hxx>
919 #include <BOPTools_ListIteratorOfListOfCommonBlock.hxx>
920 #include <BOPTools_CommonBlock.hxx>
921 #include <BOPTools_PaveFiller.hxx>
922 #include <BOPTools_CArray1OfSSInterference.hxx>
923 #include <BOPTools_SSInterference.hxx>
924 #include <BOPTools_InterferencePool.hxx>
925 #include <BOPTools_SequenceOfCurves.hxx>
926 #include <BOPTools_Curve.hxx>
927
928 #include <BOPTools_SequenceOfCurves.hxx>
929 #include <BOPTools_Curve.hxx>
930 #include <BOPTools_ListOfPaveBlock.hxx>
931 #include <BOPTools_PaveBlock.hxx>
932 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
933
934
935 static Standard_Integer bopinterf (Draw_Interpretor&, Standard_Integer, const char**);
936 static Standard_Integer bopds     (Draw_Interpretor&, Standard_Integer, const char**);
937 static Standard_Integer bopsplits (Draw_Interpretor&, Standard_Integer, const char**);
938 static Standard_Integer bopscts   (Draw_Interpretor&, Standard_Integer, const char**);
939 static Standard_Integer bopsamedomain(Draw_Interpretor&, Standard_Integer, const char**);
940 static Standard_Integer bopaves   (Draw_Interpretor&, Standard_Integer, const char**);
941 static Standard_Integer bopsinf   (Draw_Interpretor&, Standard_Integer, const char**);
942 static Standard_Integer bopsonf   (Draw_Interpretor&, Standard_Integer, const char**);
943 static Standard_Integer bopnews   (Draw_Interpretor& ,Standard_Integer, const char**);
944
945 //=======================================================================
946 //function : TSTCommands
947 //purpose  : 
948 //=======================================================================
949   void  BOPTest::TSTCommands(Draw_Interpretor& theCommands)
950 {
951   static Standard_Boolean done = Standard_False;
952   if (done) return;
953   done = Standard_True;
954   // Chapter's name
955   const char* g = "CCR commands";
956   //
957   theCommands.Add("bopinterf" , "", __FILE__, bopinterf, g);
958   theCommands.Add("bopds"     , "Use  bopds [-sw]", __FILE__, bopds, g);
959
960   theCommands.Add("bopsplits" , "", __FILE__, bopsplits, g);
961   theCommands.Add("bopscts"   , "", __FILE__, bopscts, g);
962
963   theCommands.Add("bopsamedomain" , "", __FILE__, bopsamedomain, g);//SameDomain Edges
964   theCommands.Add("bopaves"    , "", __FILE__, bopaves, g);
965   theCommands.Add("bopnews"    , "bopnews [-f,w,e,v]", __FILE__, bopnews, g);
966   //
967   // All Splits of face1 IN face2  
968   theCommands.Add("bopsinf" , "Use bopsinf #F1 #F2", __FILE__, bopsinf, g);
969   //
970   // All Splits of face1 ON face2  
971   theCommands.Add("bopsonf" , "Use bopsinf #F1 #F2", __FILE__, bopsonf, g);
972 }
973
974
975 //=======================================================================
976 //function : bopinterf
977 //purpose  : 
978 //=======================================================================
979 Standard_Integer bopinterf (Draw_Interpretor& di, 
980                             Standard_Integer /*n*/, 
981                             const char** /*a*/)
982 {
983   if (pDF==NULL) {
984     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
985     return 0;
986   }
987
988   Standard_Integer i, aNbLines;
989   //
990   // InterferenceTable
991   Standard_Integer aWith, anIndex, aFst, aLF;
992   BooleanOperations_KindOfInterference aType;
993
994   const BOPTools_InterferencePool& anInterferencePool=pDF->InterfPool();
995   const BOPTools_CArray1OfInterferenceLine& aTableIL=anInterferencePool.InterferenceTable();
996   
997   aNbLines=aTableIL.Extent();
998   for (i=1; i<=aNbLines; ++i) {
999     aFst=0;
1000     aLF=0;
1001     const BOPTools_InterferenceLine& aIL=aTableIL(i);
1002     const BOPTools_ListOfInterference& aIList=aIL.List();
1003     BOPTools_ListIteratorOfListOfInterference anIt(aIList);
1004     for (; anIt.More(); anIt.Next()) {
1005       const BOPTools_Interference& anInterf=anIt.Value();
1006       aWith=anInterf.With();
1007       aType=anInterf.Type();
1008       anIndex=anInterf.Index();
1009       if (anIndex) {
1010         if (aFst==0){
1011           //printf(" #%d ", i);
1012           di << " #" << i << " ";
1013           aFst=1;
1014         }
1015         aLF=1;
1016         //printf("(%d, %d, %d),", aWith, aType, anIndex);
1017         di << "(" << aWith << ", " << aType << ", " << anIndex << "),";
1018       }
1019     }
1020     if (aLF) {
1021       //printf("\n");
1022       di << "\n";
1023     }
1024   }
1025   return 0;
1026 }
1027
1028 //=======================================================================
1029 //function : bopds
1030 //purpose  : 
1031 //=======================================================================
1032 Standard_Integer bopds (Draw_Interpretor& di, 
1033                         Standard_Integer n, 
1034                         const char** a)
1035 {
1036   if (pDF==NULL) {
1037     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1038     return 0;
1039   }
1040
1041   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1042   Standard_Integer i, aNbLines;
1043   
1044   i=1;
1045   aNbLines=aDS.NumberOfSourceShapes();
1046   
1047   if (n==3) {
1048     if (!strcmp (a[2], "-o")) {
1049       aDS.ObjectRange(i, aNbLines);
1050     }
1051     if (!strcmp (a[2], "-t")) {
1052       aDS.ToolRange(i, aNbLines);
1053     }
1054   }
1055
1056   Draw_Color aTextColor(Draw_cyan);
1057   TCollection_AsciiString aNm("z");
1058
1059   for (; i<=aNbLines; ++i) {
1060     
1061     const TopoDS_Shape& aS=aDS.GetShape(i);
1062     //
1063     // Prestentation
1064     TopAbs_ShapeEnum aType=aS.ShapeType();
1065     if (n==1) {
1066       if (aType==TopAbs_COMPOUND ||
1067           aType==TopAbs_COMPSOLID ||
1068           aType==TopAbs_SOLID ||
1069           aType==TopAbs_SHELL || 
1070           aType==TopAbs_FACE  || 
1071           aType==TopAbs_WIRE) {
1072         continue;
1073       }
1074     }
1075
1076     if (n>=2) {
1077       if (!strcmp (a[1], "-c")) {
1078         if (aType!=TopAbs_COMPOUND) {
1079           continue;
1080         }
1081       }
1082       else if (!strcmp (a[1], "-cs")) {
1083         if (aType!=TopAbs_COMPSOLID) {
1084           continue;
1085         }
1086       }
1087       else if (!strcmp (a[1], "-s")) {
1088         if (aType!=TopAbs_SOLID) {
1089           continue;
1090         }
1091       }
1092       else if (!strcmp (a[1], "-sh")) {
1093         if (aType!=TopAbs_SHELL) {
1094           continue;
1095         }
1096       }
1097       else if (!strcmp (a[1], "-f")) {
1098         if (aType!=TopAbs_FACE) {
1099           continue;
1100         }
1101       }
1102       else if (!strcmp (a[1], "-w")) {
1103         if (aType!=TopAbs_WIRE) {
1104           continue;
1105         }
1106       }
1107      else  if (!strcmp (a[1], "-e")) {
1108         if (aType!=TopAbs_EDGE) {
1109           continue;
1110         }
1111       }
1112       else if (!strcmp (a[1], "-v")) {
1113         if (aType!=TopAbs_VERTEX) {
1114           continue;
1115         }
1116       }
1117       else {
1118         continue;
1119       }
1120     }
1121
1122     TCollection_AsciiString aInd(i), aName;
1123     aName=aNm+aInd;
1124     Standard_CString aText=aName.ToCString();
1125
1126     Handle(BOPTest_DrawableShape) aDShape=
1127       new BOPTest_DrawableShape (aS, aText, aTextColor);
1128     Draw::Set (aText, aDShape);
1129   }
1130   return 0;
1131 }
1132
1133 //=======================================================================
1134 //function : bopaves
1135 //purpose  : 
1136 //=======================================================================
1137 Standard_Integer  bopaves(Draw_Interpretor& di, 
1138                           Standard_Integer /*n*/, 
1139                           const char** /*a*/)
1140 {
1141   if (pDF==NULL) {
1142     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1143     return 0;
1144   } 
1145   Standard_Integer i, aNbLines, anIndex;
1146   Standard_Real aParam;
1147
1148   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1149   const BOPTools_PavePool& aPavePool=pDF->PavePool();
1150
1151   aNbLines=aDS.NumberOfSourceShapes();
1152   for (i=1; i<=aNbLines; ++i) {
1153     const TopoDS_Shape& aS=aDS.GetShape(i);
1154     if (aS.ShapeType()==TopAbs_EDGE) {
1155       //printf(" Edge#%d\n", i);
1156       di << " Edge#" << i << "\n";
1157       const BOPTools_PaveSet& aPaveSet=aPavePool(aDS.RefEdge(i));
1158       const BOPTools_ListOfPave& aLP= aPaveSet.Set();
1159       BOPTools_ListIteratorOfListOfPave anIt(aLP);
1160       for (; anIt.More(); anIt.Next()){
1161         const BOPTools_Pave& aPave=anIt.Value();
1162         anIndex=aPave.Index();
1163         aParam =aPave.Param();
1164         //printf(" VertIndex=%d, aParam=%f\n", anIndex, aParam);
1165         di << " VertIndex=" << anIndex << ", aParam=" << aParam << "\n";
1166       }
1167     }
1168   }
1169   return 0;
1170 }
1171
1172 //=======================================================================
1173 //function : bopsd
1174 //purpose  : SameDomain Edges
1175 //=======================================================================
1176 Standard_Integer bopsamedomain (Draw_Interpretor& di, 
1177                                 Standard_Integer /*n*/, 
1178                                 const char** /*a*/)
1179 {
1180   if (pDF==NULL) {
1181     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1182     return 0;
1183   } 
1184   TCollection_AsciiString aNm("s");
1185   
1186   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1187   const BOPTools_CommonBlockPool& aCommonBlockPool=pDF->CommonBlockPool();
1188
1189   Standard_Integer i, aNbLines, nFSD, nESD1, nESD2, nOriginal2;
1190
1191   aNbLines=aDS.NumberOfSourceShapes();
1192   for (i=1; i<=aNbLines; ++i) {
1193     const TopoDS_Shape& aSE=aDS.GetShape(i);
1194     TopAbs_ShapeEnum aType=aSE.ShapeType();
1195     if (aType==TopAbs_EDGE) {
1196       
1197       const BOPTools_ListOfCommonBlock& aLCB=aCommonBlockPool(aDS.RefEdge(i));
1198       
1199       if (aLCB.Extent()) {
1200         //
1201         BOPTools_ListIteratorOfListOfCommonBlock anIt(aLCB);
1202         for (; anIt.More(); anIt.Next()) {
1203           const BOPTools_CommonBlock& aCB=anIt.Value();
1204           nFSD=aCB.Face();
1205           if (nFSD) {
1206             const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1();
1207             nESD1=aPB1.Edge();
1208             
1209             TCollection_AsciiString aInd(i), anUnd("_"), aName;
1210             aName=aNm+aInd;
1211             aName=aName+anUnd;
1212             aName=aName+nESD1;
1213             Standard_CString aText=aName.ToCString();
1214             
1215             //printf(" (EF %s  %df),", aText, nFSD);
1216             di << " (EF " << aText << "  " << nFSD << "f),";
1217           }
1218
1219           else {
1220             const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1();
1221             nESD1=aPB1.Edge();
1222
1223             TCollection_AsciiString aInd(i), anUnd("_"), aName;
1224             aName=aNm+aInd;
1225             aName=aName+anUnd;
1226             aName=aName+nESD1;
1227             Standard_CString aText=aName.ToCString();
1228
1229             const BOPTools_PaveBlock& aPB2=aCB.PaveBlock2();
1230             nESD2=aPB2.Edge();
1231             nOriginal2=aPB2.OriginalEdge();
1232
1233             TCollection_AsciiString aInd2(nOriginal2), aName2;
1234             aName2=aNm+aInd2;
1235             aName2=aName2+anUnd;
1236             aName2=aName2+nESD2;
1237             Standard_CString aText2=aName2.ToCString();
1238
1239             //printf(" (EE %s %s ),", aText, aText2);
1240             di << " (EE " << aText << " " << aText2 << " ),";
1241           }
1242         }
1243         //printf("\n");
1244         di << "\n";
1245       }
1246     }
1247   }
1248   return 0;
1249 }
1250 //=======================================================================
1251 //function : bopnews
1252 //purpose  : 
1253 //=======================================================================
1254 Standard_Integer bopnews (Draw_Interpretor& di, 
1255                           Standard_Integer n, 
1256                           const char** a)
1257
1258 {
1259   if (pDF==NULL) {
1260     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1261     return 0;
1262   }
1263
1264   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1265
1266   Standard_Integer i, iStart, aNbLinesTotal;
1267   Draw_Color aTextColor(Draw_cyan);
1268   TCollection_AsciiString aNm("z");
1269   //
1270
1271   TopAbs_ShapeEnum aType=TopAbs_EDGE;
1272   if (n>1) {
1273     if (!strcmp (a[1], "-f")) {
1274       aType=TopAbs_FACE;
1275     }
1276     else if (!strcmp (a[1], "-w")) {
1277       aType=TopAbs_WIRE;
1278     }
1279     else  if (!strcmp (a[1], "-e")) {
1280       aType=TopAbs_EDGE;
1281     }
1282     else if (!strcmp (a[1], "-v")) {
1283       aType=TopAbs_VERTEX;
1284     }
1285   }
1286   
1287   //
1288   iStart=aDS.NumberOfSourceShapes()+1;
1289   aNbLinesTotal =aDS.NumberOfInsertedShapes();
1290
1291   for (i=iStart; i<=aNbLinesTotal; ++i) {
1292     const TopoDS_Shape& aS=aDS.Shape(i);
1293     TopAbs_ShapeEnum aTypeCurrent=aS.ShapeType();
1294     if (aTypeCurrent==aType) {
1295       TCollection_AsciiString aName, aInd(i);
1296       aName=aNm+aInd;
1297       Standard_CString aText=aName.ToCString();
1298       
1299       Handle(BOPTest_DrawableShape) aDShape=
1300         new BOPTest_DrawableShape (aS, aText, aTextColor);
1301       Draw::Set (aText, aDShape);
1302       //printf("%s ", aText);
1303       di << aText << " ";
1304     }
1305   }
1306   
1307   if (iStart>aNbLinesTotal) {
1308     di << " No new shapes occured";
1309   }
1310
1311   di << "\n";
1312   return 0;
1313 }
1314
1315 //=======================================================================
1316 //function : bopsplits
1317 //purpose  : 
1318 //=======================================================================
1319 Standard_Integer bopsplits (Draw_Interpretor& di, 
1320                             Standard_Integer /*n*/, 
1321                             const char** /*a*/)
1322
1323 {
1324   if (pDF==NULL) {
1325     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1326     return 0;
1327   }
1328
1329   const BOPTools_SplitShapesPool& aSpPool=pDF->SplitShapesPool();
1330   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1331
1332   Standard_Integer i, aNbLines, aNbSplits, aSplitExist=0;
1333   Draw_Color aTextColor(Draw_cyan);
1334   TCollection_AsciiString aNm("s");
1335
1336   aNbLines=aDS.NumberOfSourceShapes();
1337   for (i=1; i<=aNbLines; ++i) {
1338     const TopoDS_Shape& aSE=aDS.GetShape(i);
1339     TopAbs_ShapeEnum aType=aSE.ShapeType();
1340     if (aType==TopAbs_EDGE) {
1341       //
1342       // Splits' Prestentation
1343       const BOPTools_ListOfPaveBlock& aSplitsList=aSpPool(aDS.RefEdge(i));
1344       aNbSplits=aSplitsList.Extent();
1345       if (aNbSplits) {
1346         if (!aSplitExist) {
1347           di << " Splits: ";
1348           aSplitExist=1;
1349         }
1350
1351         BOPTools_ListIteratorOfListOfPaveBlock anIt(aSplitsList);
1352         for (; anIt.More();anIt.Next()) {
1353           const BOPTools_PaveBlock& aPB=anIt.Value();
1354           Standard_Integer nSplit=aPB.Edge();
1355           const TopoDS_Shape& aS=aDS.GetShape(nSplit);
1356
1357           TCollection_AsciiString aInd(i), anUnd("_"), aName;
1358           aName=aNm+aInd;
1359           aName=aName+anUnd;
1360           aName=aName+nSplit;
1361           Standard_CString aText=aName.ToCString();
1362           
1363           Handle(BOPTest_DrawableShape) aDShape=
1364             new BOPTest_DrawableShape (aS, aText, aTextColor);
1365           Draw::Set (aText, aDShape);
1366           di << aText << " ";
1367         }
1368       }
1369     }
1370   }
1371   
1372   if (!aSplitExist) {
1373     di << " No splits occured";
1374   }
1375   di << "\n";
1376   return 0;
1377 }
1378
1379 //=======================================================================
1380 //function : bopscts
1381 //purpose  : 
1382 //=======================================================================
1383 Standard_Integer bopscts (Draw_Interpretor& di, 
1384                           Standard_Integer /*n*/, 
1385                           const char** /*a*/)
1386
1387 {
1388   if (pDF==NULL) {
1389     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1390     return 0;
1391   }
1392   Standard_Integer i, nF1, nF2,  aNbFFs, aNbOldSects, aSectExist=0, nSect;
1393   Standard_Integer j, aNbCurves, aNbPaveBlocks, nNewEdge;
1394   Draw_Color aTextColor(Draw_cyan);
1395   TCollection_AsciiString aNm("t");
1396
1397   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1398   const BOPTools_InterferencePool& anInterfPool=pDF->InterfPool();
1399   BOPTools_InterferencePool* pInterfPool= (BOPTools_InterferencePool*) &anInterfPool;
1400   BOPTools_CArray1OfSSInterference& aFFs=pInterfPool->SSInterferences();
1401  
1402   aNbFFs=aFFs.Extent();
1403   for (i=1; i<=aNbFFs; ++i) {
1404     BOPTools_SSInterference& aFFi=aFFs(i);
1405     //
1406     nF1=aFFi.Index1();
1407     nF2=aFFi.Index2();
1408     TCollection_AsciiString aInd(nF1), anUnd("_");
1409     //
1410     // Old Section Edges
1411     const BOPTools_ListOfPaveBlock& aSectList=aFFi.PaveBlocks();
1412     aNbOldSects=aSectList.Extent();
1413     if (aNbOldSects) {
1414       if (!aSectExist) {
1415         di << " Sects: ";
1416         aSectExist=1;
1417       }
1418
1419       BOPTools_ListIteratorOfListOfPaveBlock anIt(aSectList);
1420       for (; anIt.More();anIt.Next()) {
1421         const BOPTools_PaveBlock& aPB=anIt.Value();
1422         nSect=aPB.Edge();
1423         const TopoDS_Shape& aS=aDS.GetShape(nSect);
1424         
1425         TCollection_AsciiString aName;
1426         aName=aNm+aInd;
1427         aName=aName+anUnd;
1428         aName=aName+nSect;
1429         Standard_CString aText=aName.ToCString();
1430         
1431         Handle(BOPTest_DrawableShape) aDShape=
1432           new BOPTest_DrawableShape (aS, aText, aTextColor);
1433         Draw::Set (aText, aDShape);
1434         di << aText << " ";
1435       }
1436     }
1437     //
1438     // New Section Edges
1439     BOPTools_SequenceOfCurves& aBCurves=aFFi.Curves();
1440     aNbCurves=aBCurves.Length();
1441     for (j=1; j<=aNbCurves; j++) {
1442       BOPTools_Curve& aBC=aBCurves(j);
1443       const BOPTools_ListOfPaveBlock& aSectEdges=aBC.NewPaveBlocks();
1444       aNbPaveBlocks=aSectEdges.Extent();
1445       if (aNbPaveBlocks) {
1446         if (!aSectExist) {
1447           di << " Sects: ";
1448           aSectExist=1;
1449         }
1450       }
1451       BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSectEdges);
1452       for (; aPBIt.More(); aPBIt.Next()) {
1453         BOPTools_PaveBlock& aPB=aPBIt.Value();
1454         nNewEdge=aPB.Edge();
1455         const TopoDS_Shape& aSectEdge=aDS.GetShape(nNewEdge);
1456
1457         TCollection_AsciiString aName;
1458         aName=aNm+aInd;
1459         aName=aName+anUnd;
1460         aName=aName+nNewEdge;
1461         Standard_CString aText=aName.ToCString();
1462         
1463         Handle(BOPTest_DrawableShape) aDShape=
1464           new BOPTest_DrawableShape (aSectEdge, aText, aTextColor);
1465         Draw::Set (aText, aDShape);
1466         di << aText << " ";
1467       }
1468     }
1469   }
1470   
1471   if (!aSectExist) {
1472     di << " No section edges";
1473   }
1474   di << "\n";
1475   return 0;
1476 }
1477
1478 //=======================================================================
1479 //function : bopsinf
1480 //purpose  : 
1481 //=======================================================================
1482 Standard_Integer bopsinf (Draw_Interpretor& di, 
1483                           Standard_Integer n, 
1484                           const char** a)
1485 {
1486   if (pDF==NULL) {
1487     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1488     return 0;
1489   }
1490
1491   if (n!=3) {
1492     di << " Use: bopsinf> #F1 #F2\n";
1493     return 0;
1494   }
1495
1496   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1497
1498   Standard_Integer nSp=0, nF1, nF2, anExistFlag=0;
1499   nF1=atoi(a[1]);
1500   nF2=atoi(a[2]);
1501
1502   const TopoDS_Shape& aS1=aDS.GetShape(nF1);
1503   const TopoDS_Shape& aS2=aDS.GetShape(nF2);
1504   if (aS1.IsNull() || aS2.IsNull()) {
1505     //printf(" Null shapes #%d #%d\n", nF1, nF2 );
1506     di << " Null shapes #" << nF1 << " #" << nF2 << "\n";
1507     return 0;
1508   }
1509   
1510   if (aS1.ShapeType()!=TopAbs_FACE ||
1511       aS1.ShapeType()!=TopAbs_FACE ) {
1512     //printf(" Shapes #%d #%d are not faces\n", nF1, nF2 );
1513     di << " Shapes #" << nF1 << " #" << nF2 << " are not faces\n";
1514     return 0;
1515   }
1516
1517   TColStd_ListOfInteger aSplList;
1518   const BOPTools_PaveFiller& aPF=pDF->PaveFiller();
1519   BOPTools_PaveFiller* pPF=(BOPTools_PaveFiller*)&aPF;
1520
1521   pPF->SplitsInFace (nSp, nF1, nF2, aSplList);
1522   
1523   TColStd_ListIteratorOfListOfInteger anIt (aSplList);
1524   for (; anIt.More(); anIt.Next()) {
1525     anExistFlag=1;
1526     nSp=anIt.Value();
1527     //printf("%d, ", nSp);
1528     di << nSp << ", ";
1529   }
1530   
1531   if(anExistFlag) {
1532     di << "\n";
1533   }
1534   else {
1535     di << "No splits of Face" << nF1 << " IN Face " << nF2 << "\n";
1536   }
1537
1538 return 0;  
1539 }
1540 //=======================================================================
1541 //function : bopsonf
1542 //purpose  : 
1543 //=======================================================================
1544 Standard_Integer bopsonf (Draw_Interpretor& di, 
1545                           Standard_Integer n, 
1546                           const char** a)
1547 {
1548   if (pDF==NULL) {
1549     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1550     return 0;
1551   }
1552
1553   if (n!=3) {
1554     di << " Use: bopsonf> #F1 #F2\n";
1555     return 0;
1556   }
1557
1558   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1559
1560   Standard_Integer nSp=0, nF1, nF2, anExistFlag=0;
1561   nF1=atoi(a[1]);
1562   nF2=atoi(a[2]);
1563
1564   const TopoDS_Shape& aS1=aDS.GetShape(nF1);
1565   const TopoDS_Shape& aS2=aDS.GetShape(nF2);
1566   if (aS1.IsNull() || aS2.IsNull()) {
1567     //printf(" Null shapes #%d #%d\n", nF1, nF2 );
1568     di << " Null shapes #" << nF1 << " #" << nF2 << "\n";
1569     return 0;
1570   }
1571   
1572   if (aS1.ShapeType()!=TopAbs_FACE ||
1573       aS1.ShapeType()!=TopAbs_FACE ) {
1574     //printf(" Shapes #%d #%d are not faces\n", nF1, nF2 );
1575     di << " Shapes #" << nF1 << " #" << nF2 << " are not faces\n";
1576     return 0;
1577   }
1578
1579   TColStd_ListOfInteger aSplList;
1580   const BOPTools_PaveFiller& aPF=pDF->PaveFiller();
1581   BOPTools_PaveFiller* pPF=(BOPTools_PaveFiller*)&aPF;
1582
1583   pPF->SplitsOnFace (nSp, nF1, nF2, aSplList);
1584   
1585   TColStd_ListIteratorOfListOfInteger anIt (aSplList);
1586   for (; anIt.More(); anIt.Next()) {
1587     anExistFlag=1;
1588     nSp=anIt.Value();
1589     //printf("%d, ", nSp);
1590     di << nSp << ", ";
1591   }
1592   
1593    if(anExistFlag) {
1594     di << "\n";
1595   }
1596   else {
1597     di << "No splits of Face" << nF1 << " ON Face " << nF2 << "\n";
1598   }
1599
1600   return 0;  
1601 }
1602
1603 //=======================================================================
1604 //function : bopwho
1605 //purpose  : 
1606 //=======================================================================
1607 Standard_Integer bopwho (Draw_Interpretor& di, 
1608                          Standard_Integer n, 
1609                          const char** a)
1610 {
1611   if (pDF==NULL) {
1612     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1613     return 0;
1614   }
1615
1616   if (n!=2) {
1617     di << " Use >bopwho Index\n";
1618     return 1;
1619   }
1620   //
1621   Standard_Boolean bIsNewShape;
1622   Standard_Integer iNum, i, aNbLines, aNbObj, aNewShape, aWhat, aWith;
1623   //
1624   iNum=atoi(a[1]);
1625   if (iNum<=0) {
1626     di << " Shape Index must be >0 .\n";
1627     return 1;
1628   }
1629   //
1630   //printf("Shape #%d is ", iNum);
1631   di << "Shape #" << iNum << " is ";
1632
1633   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1634   aNbLines=aDS.NumberOfSourceShapes();
1635   //
1636   //
1637   // Old shapes processing
1638   //
1639   if (iNum>0 && iNum<=aNbLines) {
1640     di << "from the ";
1641     // Old Shape
1642     aNbObj=aDS.NumberOfShapesOfTheObject();
1643     if (iNum<=aNbObj) {
1644       di << "Object ";
1645     }
1646     else {
1647       di << "Tool ";
1648     }
1649     di << ".\n";
1650     return 0;
1651   }
1652   //
1653   bIsNewShape=aDS.IsNewShape(iNum);
1654   if (bIsNewShape) {
1655     di << "new.\n";
1656   }
1657
1658   else {
1659     di << "undefined.\n";
1660     return 0;
1661   }
1662   //
1663   // New shapes processing
1664   //
1665   const TopoDS_Shape& aShapeToFind=aDS.Shape(iNum);
1666   TopAbs_ShapeEnum aTypeOfShapeToFind=aShapeToFind.ShapeType();
1667   //
1668   // Interferences
1669   const BOPTools_InterferencePool& anInterferencePool=pDF->InterfPool();
1670   //
1671   const BOPTools_CArray1OfVVInterference&  aVVInterfs=anInterferencePool.VVInterfs();
1672   const BOPTools_CArray1OfVEInterference&  aVEInterfs=anInterferencePool.VEInterfs();
1673   const BOPTools_CArray1OfVSInterference&  aVSInterfs=anInterferencePool.VSInterfs();
1674   const BOPTools_CArray1OfEEInterference&  aEEInterfs=anInterferencePool.EEInterfs();
1675   const BOPTools_CArray1OfESInterference&  aESInterfs=anInterferencePool.ESInterfs();
1676   //
1677   // VV
1678   aNbLines=aVVInterfs.Extent();
1679   for (i=1; i<=aNbLines; ++i) {
1680     aNewShape=aVVInterfs(i).NewShape();
1681     if (aNewShape==iNum) {
1682       aVVInterfs(i).Indices(aWhat, aWith);
1683       //printf(" VV: (%d, %d)\n", aWhat, aWith);
1684       di << " VV: (" << aWhat << ", " << aWith << ")\n";
1685     }
1686   }
1687   //
1688   // VE
1689   aNbLines=aVEInterfs.Extent();
1690   for (i=1; i<=aNbLines; ++i) {
1691     aNewShape=aVEInterfs(i).NewShape();
1692     if (aNewShape==iNum) {
1693       aVEInterfs(i).Indices(aWhat, aWith);
1694       //printf(" VE: (%d, %d)\n", aWhat, aWith);
1695       di << " VE: (" << aWhat << ", " << aWith << ")\n";
1696     }
1697   }
1698   //
1699   // VF
1700   aNbLines=aVSInterfs.Extent();
1701   for (i=1; i<=aNbLines; ++i) {
1702     aNewShape=aVSInterfs(i).NewShape();
1703     if (aNewShape==iNum) {
1704       aVSInterfs(i).Indices(aWhat, aWith);
1705       //printf(" VF: (%d, %d)\n", aWhat, aWith);
1706       di << " VF: (" << aWhat << ", " << aWith << ")\n";
1707     }
1708   }
1709   //
1710   // EE
1711   aNbLines=aEEInterfs.Extent();
1712   for (i=1; i<=aNbLines; ++i) {
1713     aNewShape=aEEInterfs(i).NewShape();
1714     if (aNewShape==iNum) {
1715       aEEInterfs(i).Indices(aWhat, aWith);
1716       //printf(" EE: (%d, %d)\n", aWhat, aWith);
1717       di << " EE: (" << aWhat << ", " << aWith << ")\n";
1718     }
1719   }
1720   //
1721   // EF
1722   aNbLines=aESInterfs.Extent();
1723   for (i=1; i<=aNbLines; ++i) {
1724     aNewShape=aESInterfs(i).NewShape();
1725     if (aNewShape==iNum) {
1726       aESInterfs(i).Indices(aWhat, aWith);
1727       //printf(" EF: (%d, %d)\n", aWhat, aWith);
1728       di << " EF: (" << aWhat << ", " << aWith << ")\n";
1729     }
1730   }
1731   //
1732   // FF
1733   Standard_Integer j, aNbCurves;
1734   //
1735   BOPTools_InterferencePool* pInterPool=(BOPTools_InterferencePool*)&pDF->InterfPool();
1736   BOPTools_CArray1OfSSInterference&  aSSInterfs=pInterPool->SSInterferences();
1737   //
1738   aNbLines=aSSInterfs.Extent();
1739   for (i=1; i<=aNbLines; ++i) {
1740     BOPTools_SSInterference& aFF=aSSInterfs(i);
1741     aWhat=aFF.Index1();
1742     aWith=aFF.Index2();
1743     
1744     
1745     BOPTools_SequenceOfCurves& aSC=aFF.Curves();
1746     
1747     aNbCurves=aSC.Length();
1748     for (j=1; j<=aNbCurves; ++j) {
1749       const BOPTools_Curve& aBC=aSC(j);
1750
1751       if (aTypeOfShapeToFind==TopAbs_EDGE) {
1752         const BOPTools_ListOfPaveBlock& aLPB=aBC.NewPaveBlocks();
1753         BOPTools_ListIteratorOfListOfPaveBlock anIt(aLPB);
1754         for (; anIt.More(); anIt.Next()) {
1755           const BOPTools_PaveBlock& aPB=anIt.Value();
1756           aNewShape=aPB.Edge();
1757           if (aNewShape==iNum) {
1758             //printf(" FF: (%d, %d) [Section Edge]\n", aWhat, aWith);
1759             di << " FF: (" << aWhat << ", " << aWith << ") [Section Edge]\n";
1760           }
1761         }
1762       }
1763       //
1764       if (aTypeOfShapeToFind==TopAbs_VERTEX) {
1765         BOPTools_Curve* pBC=(BOPTools_Curve*)&aBC;
1766         TColStd_ListOfInteger& aTVList=pBC->TechnoVertices();
1767         TColStd_ListIteratorOfListOfInteger aTVIt(aTVList);
1768         for (; aTVIt.More(); aTVIt.Next()) {
1769           aNewShape=aTVIt.Value();
1770           if (aNewShape==iNum) {
1771             //printf(" FF: (%d, %d) [Techno Vertex]\n", aWhat, aWith);
1772             di << " FF: (" << aWhat << ", " << aWith << ") [Techno Vertex]\n";
1773           }
1774         }
1775       }
1776     }
1777     //
1778     if (aTypeOfShapeToFind==TopAbs_VERTEX) {
1779       TColStd_ListOfInteger& anAVList=aFF.AloneVertices();
1780       TColStd_ListIteratorOfListOfInteger anAVIt(anAVList);
1781       for (; anAVIt.More(); anAVIt.Next()) {
1782         aNewShape=anAVIt.Value();
1783         if (aNewShape==iNum) {
1784           //printf(" FF: (%d, %d) [Alone Vertex]\n", aWhat, aWith);
1785           di << " FF: (" << aWhat << ", " << aWith << ") [Alone Vertex]\n";
1786         }
1787       }
1788     }
1789   }
1790   //
1791   // 
1792   // PaveBlocks 
1793   if (aTypeOfShapeToFind==TopAbs_EDGE) {
1794     //
1795     Standard_Integer aNbPaveBlocks, nE, nOriginalEdge, aNbCommonBlocks;
1796     Standard_Integer nFace, nE2,  nOriginalEdge2;
1797     //
1798     const BOPTools_CommonBlockPool& aCommonBlockPool=pDF->CommonBlockPool();
1799     const BOPTools_SplitShapesPool& aSplitShapesPool=pDF->SplitShapesPool();
1800     aNbLines=aSplitShapesPool.Extent();
1801     for (i=1; i<=aNbLines; ++i) {
1802       const BOPTools_ListOfPaveBlock& aSplitEdges=aSplitShapesPool(i);
1803       aNbPaveBlocks=aSplitEdges.Extent();
1804       
1805       BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSplitEdges);
1806       for (; aPBIt.More(); aPBIt.Next()) {
1807         const BOPTools_PaveBlock& aPB=aPBIt.Value();
1808         nE=aPB.Edge();
1809         nOriginalEdge=aPB.OriginalEdge();
1810         if (nE==iNum) {
1811           //printf("  PaveBlock [Base Edge #%d]\n", nOriginalEdge);
1812           di << "  PaveBlock [Base Edge #" << nOriginalEdge << "]\n";
1813           const BOPTools_ListOfCommonBlock& aLCB=
1814             aCommonBlockPool(aDS.RefEdge(nOriginalEdge));
1815           aNbCommonBlocks=aLCB.Extent();
1816           
1817           BOPTools_ListIteratorOfListOfCommonBlock aCBIt(aLCB);
1818           for (; aCBIt.More(); aCBIt.Next()) {
1819             BOPTools_CommonBlock& aCB=aCBIt.Value();
1820             nFace=aCB.Face();
1821             if (nFace) {
1822               //printf("  CommonBlock with Face #%d\n", nFace);
1823               di << "  CommonBlock with Face #" << nFace << "\n";
1824             }
1825             else {
1826               BOPTools_PaveBlock& aPB2=aCB.PaveBlock2(nOriginalEdge);
1827               nE2=aPB2.Edge();
1828               nOriginalEdge2=aPB2.OriginalEdge();
1829               //printf("  CommonBlock with Edge #%d [Base Edge #%d]\n", 
1830                 //     nE2, nOriginalEdge2);
1831               di << "  CommonBlock with Edge #" << nE2 << " [Base Edge #" << nOriginalEdge2 << "]\n"; 
1832             }
1833           }
1834           
1835         }
1836       }
1837     }
1838     
1839   }
1840   return 0; 
1841 }
1842
1843 //=======================================================================
1844 //function : bopsticks
1845 //purpose  : 
1846 //=======================================================================
1847 Standard_Integer bopsticks (Draw_Interpretor& di, 
1848                             Standard_Integer n, 
1849                             const char** )
1850 {
1851   if (pDF==NULL) {
1852     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1853     return 1;
1854   }
1855   //
1856   if (n!=1) {
1857     di << " Use >bopsticks\n";
1858     return 1;
1859   }
1860   //
1861   Standard_Integer i, j, aNbLines, nF1, nF2, aNbVtx, nV;
1862   //
1863   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1864   const BOPTools_PaveFiller& aPF=pDF->PaveFiller();
1865   BOPTools_PaveFiller* pPF=(BOPTools_PaveFiller*)&aPF;
1866   BOPTools_InterferencePool* pInterPool=(BOPTools_InterferencePool*)&pDF->InterfPool();
1867   BOPTools_CArray1OfSSInterference&  aSSInterfs=pInterPool->SSInterferences();
1868   //
1869   aNbLines=aSSInterfs.Extent();
1870   //
1871   for (i=1; i<=aNbLines; ++i) {
1872     TColStd_IndexedMapOfInteger aMapUnUsed;
1873     BOPTools_PaveSet aPSF;
1874     //
1875     BOPTools_SSInterference& aFF=aSSInterfs(i);
1876     BOPTools_SequenceOfCurves& aSCvs=aFF.Curves();
1877
1878     nF1=aFF.Index1();
1879     nF2=aFF.Index2();
1880     
1881     pPF->PrepareSetForFace(nF1, nF2, aPSF);
1882     UnUsedMap(aSCvs, aPSF, aMapUnUsed);
1883     aNbVtx=aMapUnUsed.Extent();
1884     for (j=1; j<=aNbVtx; ++j) {
1885       nV=aMapUnUsed(j);
1886       if (aDS.IsNewShape(nV)) {
1887         //printf(" Vertex #%d [FF:(%d, %d)]\n", nV, nF1, nF2);
1888         di << " Vertex #" << nV << " [FF:(" << nF1 << ", " << nF2 << ")]\n";
1889       }
1890     }
1891   }
1892   return 0;  
1893 }
1894
1895 //=======================================================================
1896 // function: UnUsedMap
1897 // purpose: 
1898 //=======================================================================
1899 void UnUsedMap(BOPTools_SequenceOfCurves& aSCvs,
1900                const BOPTools_PaveSet& aPSF,
1901                TColStd_IndexedMapOfInteger& aMapUnUsed)
1902 {
1903   //
1904   // What stick/non-stick vertices we used 
1905   TColStd_IndexedMapOfInteger aMapUsed, aMapMustBeUsed;
1906   Standard_Integer j, aNbCurves, aNbVtx, nV1;//, nV2;
1907   BOPTools_ListIteratorOfListOfPave anLPIt;
1908
1909   aNbCurves=aSCvs.Length();
1910   for (j=1; j<=aNbCurves; ++j) {
1911     BOPTools_Curve& aBC=aSCvs(j);
1912     //const IntTools_Curve& aC= aBC.Curve();// Wng in Gcc 3.0
1913         
1914     const BOPTools_PaveSet& aPaveSet=aBC.Set();
1915     const BOPTools_ListOfPave& aLPAlreadyUsed=aPaveSet.Set();
1916     anLPIt.Initialize(aLPAlreadyUsed);
1917     for (; anLPIt.More(); anLPIt.Next()) {
1918       const BOPTools_Pave& aPave=anLPIt.Value();
1919       nV1=aPave.Index();
1920       aMapUsed.Add(nV1);
1921     }
1922   }
1923   // 
1924   // 2. Stick vertices that must be used
1925   const BOPTools_ListOfPave& aLPMustUsed=aPSF.Set();
1926   anLPIt.Initialize(aLPMustUsed);
1927   for (; anLPIt.More(); anLPIt.Next()) {
1928     const BOPTools_Pave& aPave=anLPIt.Value();
1929     nV1=aPave.Index();
1930     aMapMustBeUsed.Add(nV1);
1931   }
1932   //
1933   // 3.Unused Stick vertices .
1934   aNbVtx=aMapMustBeUsed.Extent();
1935   for (j=1; j<=aNbVtx; ++j) {
1936     nV1=aMapMustBeUsed(j);
1937     if (!aMapUsed.Contains(nV1)) {
1938       aMapUnUsed.Add(nV1);
1939     }
1940   }
1941   // 
1942 }