7d7ae9cf7dd14627a52326ac747afa033afba124
[occt.git] / src / HLRBRep / HLRBRep_InternalAlgo.cxx
1 // Created on: 1997-04-17
2 // Created by: Christophe MARION
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <Standard_Stream.hxx>
18 #include <HLRBRep_InternalAlgo.ixx>
19
20 #include <Standard_ErrorHandler.hxx>
21 #include <TColStd_Array1OfReal.hxx>
22 #include <HLRAlgo.hxx>
23 #include <HLRBRep_ShapeToHLR.hxx>
24 #include <HLRBRep_Hider.hxx>
25 #include <stdio.h>
26
27 extern Standard_Integer nbPtIntersection;   // total P.I.
28 extern Standard_Integer nbSegIntersection;  // total S.I
29 extern Standard_Integer nbClassification;   // total classification
30 extern Standard_Integer nbOkIntersection;   // pairs of intersecting edges
31 extern Standard_Integer nbCal1Intersection; // pairs of unrejected edges
32 extern Standard_Integer nbCal2Intersection; // true intersections (not vertex)
33 extern Standard_Integer nbCal3Intersection; // curve-surface intersections
34
35 static Standard_Integer TRACE = Standard_True;
36 static Standard_Integer TRACE10 = Standard_True; 
37
38 #define MinShBI1 MinMaxShBI[ 0]
39 #define MinShBI2 MinMaxShBI[ 1]
40 #define MinShBI3 MinMaxShBI[ 2]
41 #define MinShBI4 MinMaxShBI[ 3]
42 #define MinShBI5 MinMaxShBI[ 4]
43 #define MinShBI6 MinMaxShBI[ 5]
44 #define MinShBI7 MinMaxShBI[ 6]
45 #define MinShBI8 MinMaxShBI[ 7]
46 #define MaxShBI1 MinMaxShBI[ 8]
47 #define MaxShBI2 MinMaxShBI[ 9]
48 #define MaxShBI3 MinMaxShBI[10]
49 #define MaxShBI4 MinMaxShBI[11]
50 #define MaxShBI5 MinMaxShBI[12]
51 #define MaxShBI6 MinMaxShBI[13]
52 #define MaxShBI7 MinMaxShBI[14]
53 #define MaxShBI8 MinMaxShBI[15]
54
55 #define MinShBJ1 MinMaxShBJ[ 0]
56 #define MinShBJ2 MinMaxShBJ[ 1]
57 #define MinShBJ3 MinMaxShBJ[ 2]
58 #define MinShBJ4 MinMaxShBJ[ 3]
59 #define MinShBJ5 MinMaxShBJ[ 4]
60 #define MinShBJ6 MinMaxShBJ[ 5]
61 #define MinShBJ7 MinMaxShBJ[ 6]
62 #define MinShBJ8 MinMaxShBJ[ 7]
63 #define MaxShBJ1 MinMaxShBJ[ 8]
64 #define MaxShBJ2 MinMaxShBJ[ 9]
65 #define MaxShBJ3 MinMaxShBJ[10]
66 #define MaxShBJ4 MinMaxShBJ[11]
67 #define MaxShBJ5 MinMaxShBJ[12]
68 #define MaxShBJ6 MinMaxShBJ[13]
69 #define MaxShBJ7 MinMaxShBJ[14]
70 #define MaxShBJ8 MinMaxShBJ[15]
71
72 //=======================================================================
73 //function : HLRBRep_InternalAlgo
74 //purpose  : 
75 //=======================================================================
76
77 HLRBRep_InternalAlgo::HLRBRep_InternalAlgo () :
78 myDebug       (Standard_False)
79 {
80 }
81
82 //=======================================================================
83 //function : HLRBRep_InternalAlgo
84 //purpose  : 
85 //=======================================================================
86
87 HLRBRep_InternalAlgo::
88 HLRBRep_InternalAlgo (const Handle(HLRBRep_InternalAlgo)& A)
89 {
90   myDS          = A->DataStructure();
91   myProj        = A->Projector();
92   myShapes      = A->SeqOfShapeBounds();
93   myDebug       = A->Debug();
94 }
95
96 //=======================================================================
97 //function : Projector
98 //purpose  : 
99 //=======================================================================
100
101 void HLRBRep_InternalAlgo::Projector (const HLRAlgo_Projector& P)
102 {
103   myProj = P;
104 }
105
106 //=======================================================================
107 //function : Projector
108 //purpose  : 
109 //=======================================================================
110
111 HLRAlgo_Projector & HLRBRep_InternalAlgo::Projector ()
112 { return myProj; }
113
114 //=======================================================================
115 //function : Update
116 //purpose  : 
117 //=======================================================================
118
119 void HLRBRep_InternalAlgo::Update ()
120 {
121   if (!myShapes.IsEmpty()) {
122     Standard_Integer n = myShapes.Length();
123     Handle(HLRBRep_Data) *DS = new Handle(HLRBRep_Data) [n];
124
125     Standard_Integer i,dv,de,df,nv=0,ne=0,nf=0;
126
127     for (i = 1; i <= n; i++) {
128       HLRBRep_ShapeBounds& SB = myShapes(i);
129       try {
130         OCC_CATCH_SIGNALS
131         DS[i-1] = HLRBRep_ShapeToHLR::Load(SB.Shape(),
132                                            myProj,
133                                            myMapOfShapeTool,
134                                            SB.NbOfIso());
135         dv = DS[i-1]->NbVertices();
136         de = DS[i-1]->NbEdges   ();
137         df = DS[i-1]->NbFaces   ();
138       }
139       catch(Standard_Failure) {
140         cout << "An exception was catched when preparing the Shape " << i;
141         cout << " and computing its OutLines " << endl;
142         Handle(Standard_Failure) fail = Standard_Failure::Caught();
143         cout << fail << endl;
144         DS[i-1] = new HLRBRep_Data(0,0,0);
145         dv = 0;
146         de = 0;
147         df = 0;
148       }
149
150       SB = HLRBRep_ShapeBounds
151         (SB.Shape(),SB.ShapeData(),SB.NbOfIso(),1,dv,1,de,1,df);
152       nv += dv;
153       ne += de;
154       nf += df;
155     }
156
157     if (n == 1) myDS = DS[0];
158     else {
159       myDS = new HLRBRep_Data(nv,ne,nf);
160       nv = 0;
161       ne = 0;
162       nf = 0;
163
164       for (i = 1; i <= n; i++) {
165         HLRBRep_ShapeBounds& SB = myShapes(i);
166         SB.Sizes(dv,de,df);
167         SB.Translate(nv,ne,nf);
168         myDS->Write(DS[i-1],nv,ne,nf);
169         nv += dv;
170         ne += de;
171         nf += df;
172       }
173     }
174
175     delete [] DS;
176
177     myDS->Update(myProj);
178
179     Standard_Integer ShapMin[16],ShapMax[16],MinMaxShap[16];
180     Standard_Integer TheMin[16],TheMax[16];
181
182     for (i = 1; i <= n; i++) {
183       Standard_Boolean FirstTime = Standard_True;
184       HLRBRep_ShapeBounds& SB = myShapes(i);
185       Standard_Integer v1,v2,e1,e2,f1,f2;
186       SB.Bounds(v1,v2,e1,e2,f1,f2);
187
188       HLRBRep_EdgeData* ed = &(myDS->EDataArray    (). ChangeValue(e1 - 1));
189       HLRBRep_FaceData* fd = &(myDS->FDataArray    (). ChangeValue(f1 - 1));
190       ed++;
191       fd++;
192
193       for (Standard_Integer e = e1; e <= e2; e++) {
194         HLRAlgo::DecodeMinMax(ed->MinMax(),
195                               (Standard_Address)TheMin,
196                               (Standard_Address)TheMax);
197         if (FirstTime) {
198           FirstTime = Standard_False;
199           HLRAlgo::CopyMinMax((Standard_Address)TheMin,
200                               (Standard_Address)TheMax,
201                               (Standard_Address)ShapMin,
202                               (Standard_Address)ShapMax);
203         }
204         else
205           HLRAlgo::AddMinMax((Standard_Address)TheMin,
206                              (Standard_Address)TheMax,
207                              (Standard_Address)ShapMin,
208                              (Standard_Address)ShapMax);
209         ed++;
210       }
211
212       for (Standard_Integer f = f1; f <= f2; f++) {
213         HLRAlgo::DecodeMinMax(fd->Wires()->MinMax(),
214                               (Standard_Address)TheMin,
215                               (Standard_Address)TheMax);
216         HLRAlgo::AddMinMax((Standard_Address)TheMin,
217                            (Standard_Address)TheMax,
218                            (Standard_Address)ShapMin,
219                            (Standard_Address)ShapMax);
220         fd++;
221       }
222       HLRAlgo::EncodeMinMax((Standard_Address)ShapMin,
223                             (Standard_Address)ShapMax,
224                             (Standard_Address)MinMaxShap);
225       SB.UpdateMinMax((Standard_Address)MinMaxShap);
226     }
227   }
228 }
229
230 //=======================================================================
231 //function : Load
232 //purpose  : 
233 //=======================================================================
234
235 void HLRBRep_InternalAlgo::Load (const Handle(HLRTopoBRep_OutLiner)& S,
236                                  const Handle(MMgt_TShared)& SData, 
237                                  const Standard_Integer nbIso)
238
239   myShapes.Append(HLRBRep_ShapeBounds(S,SData,nbIso,0,0,0,0,0,0));
240   myDS.Nullify();
241 }
242
243 //=======================================================================
244 //function : Load
245 //purpose  : 
246 //=======================================================================
247
248 void HLRBRep_InternalAlgo::Load (const Handle(HLRTopoBRep_OutLiner)& S,
249                                  const Standard_Integer nbIso)
250
251   myShapes.Append(HLRBRep_ShapeBounds(S,nbIso,0,0,0,0,0,0));
252   myDS.Nullify();
253 }
254
255 //=======================================================================
256 //function : Index
257 //purpose  : 
258 //=======================================================================
259
260 Standard_Integer HLRBRep_InternalAlgo::
261 Index (const Handle(HLRTopoBRep_OutLiner)& S) const
262 {
263   Standard_Integer n = myShapes.Length();
264
265   for (Standard_Integer i = 1; i <= n; i++)
266     if (myShapes(i).Shape() == S) return i;
267
268   return 0;
269 }
270
271 //=======================================================================
272 //function : Remove
273 //purpose  : 
274 //=======================================================================
275
276 void HLRBRep_InternalAlgo::Remove (const Standard_Integer I)
277 {
278   Standard_OutOfRange_Raise_if
279     (I == 0 || I > myShapes.Length(),
280      "HLRBRep_InternalAlgo::Remove : unknown Shape");
281   myShapes.Remove(I);
282   
283   myMapOfShapeTool.Clear();
284   myDS.Nullify();
285 }
286
287 //=======================================================================
288 //function : ShapeData
289 //purpose  : 
290 //=======================================================================
291
292 void HLRBRep_InternalAlgo::ShapeData (const Standard_Integer I,
293                                       const Handle(MMgt_TShared)& SData)
294 {
295   Standard_OutOfRange_Raise_if
296     (I == 0 || I > myShapes.Length(),
297      "HLRBRep_InternalAlgo::ShapeData : unknown Shape");
298
299   myShapes(I).ShapeData(SData);
300 }
301
302 //=======================================================================
303 //function : SeqOfShapeBounds
304 //purpose  : 
305 //=======================================================================
306
307 HLRBRep_SeqOfShapeBounds & HLRBRep_InternalAlgo::SeqOfShapeBounds ()
308 {
309   return myShapes;
310 }
311
312 //=======================================================================
313 //function : NbShapes
314 //purpose  : 
315 //=======================================================================
316
317 Standard_Integer HLRBRep_InternalAlgo::NbShapes () const
318 { return myShapes.Length(); }
319
320 //=======================================================================
321 //function : ShapeBounds
322 //purpose  : 
323 //=======================================================================
324
325 HLRBRep_ShapeBounds & HLRBRep_InternalAlgo::
326 ShapeBounds (const Standard_Integer I)
327 {
328   Standard_OutOfRange_Raise_if
329     (I == 0 || I > myShapes.Length(),
330      "HLRBRep_InternalAlgo::ShapeBounds : unknown Shape");
331
332   return myShapes(I);
333 }
334
335 //=======================================================================
336 //function : InitEdgeStatus
337 //purpose  : 
338 //=======================================================================
339
340 void HLRBRep_InternalAlgo::InitEdgeStatus () 
341 {
342   Standard_Boolean visible;
343   HLRBRep_FaceIterator faceIt;
344   
345   HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
346   HLRBRep_FaceData* fd = &(myDS->FDataArray().ChangeValue(1));
347   Standard_Integer ne = myDS->NbEdges();
348   Standard_Integer nf = myDS->NbFaces();
349
350   for (Standard_Integer e = 1; e <= ne; e++) {
351     if (ed->Selected()) ed->Status().ShowAll();
352     ed++;
353   }
354 //  for (Standard_Integer f = 1; f <= nf; f++) {
355   Standard_Integer f;
356   for ( f = 1; f <= nf; f++) {
357     if (fd->Selected()) {
358       
359       for (faceIt.InitEdge(*fd);
360            faceIt.MoreEdge();
361            faceIt.NextEdge()) {
362         HLRBRep_EdgeData* edf = &(myDS->EDataArray().ChangeValue(faceIt.Edge()));
363         if (edf->Selected()) edf->Status().HideAll();
364       }
365     }
366     fd++;
367   }
368
369   fd = &(myDS->FDataArray().ChangeValue(1));
370
371   for (f = 1; f <= nf; f++) {
372     visible = Standard_True;
373     if (fd->Selected() && fd->Closed()) {
374       if      ( fd->Side())      visible =  Standard_False;
375       else if ( !fd->WithOutL()) {
376         switch (fd->Orientation()) {
377         case TopAbs_REVERSED : visible =  fd->Back()   ; break;
378         case TopAbs_FORWARD  : visible = !fd->Back()   ; break;
379         case TopAbs_EXTERNAL :
380         case TopAbs_INTERNAL : visible =  Standard_True; break;
381         }
382       }
383     } 
384     if (visible) {
385       
386       for (faceIt.InitEdge(*fd);
387            faceIt.MoreEdge();
388            faceIt.NextEdge()) {
389         Standard_Integer E = faceIt.Edge();
390         HLRBRep_EdgeData* edf = &(myDS->EDataArray().ChangeValue(E));
391         if ( edf->Selected() &&
392             !edf->Vertical())
393           edf->Status().ShowAll();
394       }
395     }
396     fd++;
397   }
398 }
399
400 //=======================================================================
401 //function : Select
402 //purpose  : 
403 //=======================================================================
404
405 void HLRBRep_InternalAlgo::Select ()
406 {
407   if (!myDS.IsNull()) {
408     HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
409     HLRBRep_FaceData* fd = &(myDS->FDataArray().ChangeValue(1));
410     Standard_Integer ne = myDS->NbEdges();
411     Standard_Integer nf = myDS->NbFaces();
412     
413     for (Standard_Integer e = 1; e <= ne; e++) {
414       ed->Selected(Standard_True);
415       ed++;
416     }
417     
418     for (Standard_Integer f = 1; f <= nf; f++) {
419       fd->Selected(Standard_True);
420       fd++;
421     }
422   }
423 }
424
425 //=======================================================================
426 //function : Select
427 //purpose  : 
428 //=======================================================================
429
430 void HLRBRep_InternalAlgo::Select (const Standard_Integer I)
431 {
432   if (!myDS.IsNull()) { 
433     Standard_OutOfRange_Raise_if
434       (I == 0 || I > myShapes.Length(),
435        "HLRBRep_InternalAlgo::Select : unknown Shape");
436
437     Standard_Integer v1,v2,e1,e2,f1,f2;
438     myShapes(I).Bounds(v1,v2,e1,e2,f1,f2);
439     
440     HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
441     HLRBRep_FaceData* fd = &(myDS->FDataArray().ChangeValue(1));
442     Standard_Integer ne = myDS->NbEdges();
443     Standard_Integer nf = myDS->NbFaces();
444     
445     for (Standard_Integer e = 1; e <= ne; e++) {
446       ed->Selected(e >= e1 && e <= e2);
447       ed++;
448     }
449     
450     for (Standard_Integer f = 1; f <= nf; f++) {
451       fd->Selected(f >= f1 && f <= f2);
452       fd++;
453     }
454   }
455 }
456
457 //=======================================================================
458 //function : SelectEdge
459 //purpose  : 
460 //=======================================================================
461
462 void HLRBRep_InternalAlgo::SelectEdge (const Standard_Integer I)
463 {
464   if (!myDS.IsNull()) {
465     Standard_OutOfRange_Raise_if
466       (I == 0 || I > myShapes.Length(),
467        "HLRBRep_InternalAlgo::SelectEdge : unknown Shape");
468     
469     Standard_Integer v1,v2,e1,e2,f1,f2;
470     myShapes(I).Bounds(v1,v2,e1,e2,f1,f2);
471     
472     HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
473     Standard_Integer ne = myDS->NbEdges();
474     
475     for (Standard_Integer e = 1; e <= ne; e++) {
476       ed->Selected(e >= e1 && e <= e2);
477       ed++;
478     }
479   }
480 }
481
482 //=======================================================================
483 //function : SelectFace
484 //purpose  : 
485 //=======================================================================
486
487 void HLRBRep_InternalAlgo::SelectFace (const Standard_Integer I)
488 {
489   if (!myDS.IsNull()) {
490     Standard_OutOfRange_Raise_if
491       (I == 0 || I > myShapes.Length(),
492        "HLRBRep_InternalAlgo::SelectFace : unknown Shape");
493     
494     Standard_Integer v1,v2,e1,e2,f1,f2;
495     myShapes(I).Bounds(v1,v2,e1,e2,f1,f2);
496     
497     HLRBRep_FaceData* fd = &(myDS->FDataArray().ChangeValue(1));
498     Standard_Integer nf = myDS->NbFaces();
499     
500     for (Standard_Integer f = 1; f <= nf; f++) {
501       fd->Selected(f >= f1 && f <= f2);
502       fd++;
503     }
504   }
505 }
506
507 //=======================================================================
508 //function : ShowAll
509 //purpose  : 
510 //=======================================================================
511
512 void HLRBRep_InternalAlgo::ShowAll ()
513 {
514   if (!myDS.IsNull()) {
515     HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
516     Standard_Integer ne = myDS->NbEdges();
517
518     for (Standard_Integer ie = 1; ie <= ne; ie++) {
519       ed->Status().ShowAll();
520       ed++;
521     }
522   }
523 }
524
525 //=======================================================================
526 //function : ShowAll
527 //purpose  : 
528 //=======================================================================
529
530 void HLRBRep_InternalAlgo::ShowAll (const Standard_Integer I)
531 {
532   if (!myDS.IsNull()) {
533     Standard_OutOfRange_Raise_if
534       (I == 0 || I > myShapes.Length(),
535        "HLRBRep_InternalAlgo::ShowAll : unknown Shape");
536     
537     Select(I);
538     
539     HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
540     Standard_Integer ne = myDS->NbEdges();
541     
542     for (Standard_Integer e = 1; e <= ne; e++) {
543       if (ed->Selected()) ed->Status().ShowAll();
544       ed++;
545     }
546   }
547 }
548
549 //=======================================================================
550 //function : HideAll
551 //purpose  : 
552 //=======================================================================
553
554 void HLRBRep_InternalAlgo::HideAll ()
555 {
556   if (!myDS.IsNull()) {
557     HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
558     Standard_Integer ne = myDS->NbEdges();
559     
560     for (Standard_Integer ie = 1; ie <= ne; ie++) {
561       ed->Status().HideAll();
562       ed++;
563     }
564   }
565 }
566
567 //=======================================================================
568 //function : HideAll
569 //purpose  : 
570 //=======================================================================
571
572 void HLRBRep_InternalAlgo::HideAll (const Standard_Integer I)
573 {
574   if (!myDS.IsNull()) {
575     Standard_OutOfRange_Raise_if
576       (I == 0 || I > myShapes.Length(),
577        "HLRBRep_InternalAlgo::HideAll : unknown Shape");
578     
579     Select(I);
580     
581     HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
582     Standard_Integer ne = myDS->NbEdges();
583     
584     for (Standard_Integer e = 1; e <= ne; e++) {
585       if (ed->Selected()) ed->Status().HideAll();
586       ed++;
587     }
588   }
589 }
590
591 //=======================================================================
592 //function : PartialHide
593 //purpose  : 
594 //=======================================================================
595
596 void HLRBRep_InternalAlgo::PartialHide ()
597 {
598   if (!myDS.IsNull()) {
599     Standard_Integer i,n = myShapes.Length();
600
601     if (myDebug)
602       cout << " Partial hiding" << endl << endl;
603
604     for (i = 1; i <= n; i++)
605       Hide(i);
606     
607     Select();
608   }
609 }
610
611 //=======================================================================
612 //function : Hide
613 //purpose  : 
614 //=======================================================================
615
616 void HLRBRep_InternalAlgo::Hide ()
617 {
618   if (!myDS.IsNull()) {
619     Standard_Integer i,j,n = myShapes.Length();
620
621     if (myDebug)
622       cout << " Total hiding" << endl;
623
624     for (i = 1; i <= n; i++)
625       Hide(i);
626     
627     for (i = 1; i <= n; i++)
628       for (j = 1; j <= n; j++)
629         if (i != j) Hide(i,j);
630     
631     Select();
632   }
633 }
634
635 //=======================================================================
636 //function : Hide
637 //purpose  : 
638 //=======================================================================
639
640 void HLRBRep_InternalAlgo::Hide (const Standard_Integer I)
641 {
642   if (!myDS.IsNull()) {
643     Standard_OutOfRange_Raise_if
644       (I == 0 || I > myShapes.Length(),
645        "HLRBRep_InternalAlgo::Hide : unknown Shape");
646     
647     if (myDebug)
648       cout << " hiding the shape " << I << " by itself" << endl;
649     
650     Select(I);
651     InitEdgeStatus();
652     HideSelected(I,Standard_True);
653   }
654 }
655
656 //=======================================================================
657 //function : Hide
658 //purpose  : 
659 //=======================================================================
660
661 void HLRBRep_InternalAlgo::Hide (const Standard_Integer I,
662                                  const Standard_Integer J)
663 {
664   if (!myDS.IsNull()) {
665     Standard_OutOfRange_Raise_if
666       (I == 0 || I > myShapes.Length() ||
667        J == 0 || J > myShapes.Length(),
668        "HLRBRep_InternalAlgo::Hide : unknown Shapes");
669
670     if (I == J) Hide(I);
671     else {
672       Standard_Integer* MinMaxShBI =
673         (Standard_Integer*)myShapes(I).MinMax();
674       Standard_Integer* MinMaxShBJ =
675         (Standard_Integer*)myShapes(J).MinMax();
676       if (((MaxShBJ1 - MinShBI1) & 0x80008000) == 0 &&
677           ((MaxShBI1 - MinShBJ1) & 0x80008000) == 0 &&
678           ((MaxShBJ2 - MinShBI2) & 0x80008000) == 0 &&
679           ((MaxShBI2 - MinShBJ2) & 0x80008000) == 0 &&
680           ((MaxShBJ3 - MinShBI3) & 0x80008000) == 0 &&
681           ((MaxShBI3 - MinShBJ3) & 0x80008000) == 0 &&
682           ((MaxShBJ4 - MinShBI4) & 0x80008000) == 0 &&
683           ((MaxShBI4 - MinShBJ4) & 0x80008000) == 0 &&
684           ((MaxShBJ5 - MinShBI5) & 0x80008000) == 0 &&
685           ((MaxShBI5 - MinShBJ5) & 0x80008000) == 0 &&
686           ((MaxShBJ6 - MinShBI6) & 0x80008000) == 0 &&
687           ((MaxShBI6 - MinShBJ6) & 0x80008000) == 0 &&
688           ((MaxShBJ7 - MinShBI7) & 0x80008000) == 0 &&
689           ((MaxShBJ8 - MinShBI8) & 0x80008000) == 0) {
690         if (myDebug) {
691           cout << " hiding the shape " << I;
692           cout << " by the shape : " << J << endl;
693         }
694         SelectEdge(I);
695         SelectFace(J);
696         HideSelected(I,Standard_False);
697       }
698     }
699   }
700 }
701
702 //=======================================================================
703 //function : HideSelected
704 //purpose  : 
705 //=======================================================================
706
707 void HLRBRep_InternalAlgo::HideSelected (const Standard_Integer I,
708                                          const Standard_Boolean SideFace)
709 {
710   Standard_Integer e,f,j,nbVisEdges,nbSelEdges,nbSelFaces,nbCache;
711   Standard_Integer nbFSide,nbFSimp;
712
713 #ifdef DEB
714   if (myDebug) {
715     nbPtIntersection = 0;
716     nbSegIntersection = 0;
717     nbOkIntersection = 0;
718     nbClassification = 0;
719     nbCal1Intersection = 0;
720     nbCal2Intersection = 0;
721     nbCal3Intersection = 0;
722   }
723 #endif
724
725   HLRBRep_ShapeBounds& SB = myShapes(I);
726   Standard_Integer v1,v2,e1,e2,f1,f2;
727   SB.Bounds(v1,v2,e1,e2,f1,f2);
728
729   if (e2 >= e1) {
730     myDS->InitBoundSort(SB.MinMax(),e1,e2);
731     HLRBRep_Hider Cache(myDS);
732     HLRBRep_EdgeData* ed = &(myDS->EDataArray().ChangeValue(1));
733     HLRBRep_FaceData* fd = &(myDS->FDataArray().ChangeValue(1));
734     Standard_Integer ne = myDS->NbEdges();
735     Standard_Integer nf = myDS->NbFaces();
736     
737     if (myDebug) {
738       nbVisEdges = 0;
739       nbSelEdges = 0;
740       nbSelFaces = 0;
741       nbCache = 0;
742       nbFSide = 0;
743       nbFSimp = 0;
744       
745       for (e = 1; e <= ne; e++) {
746         if (ed->Selected()) {
747           nbSelEdges++;
748           if (!ed->Status().AllHidden()) nbVisEdges++;
749         }
750         ed++;
751       }
752       
753       for (f = 1; f <= nf; f++) {
754         if (fd->Selected()) {
755           nbSelFaces++;
756           if (fd->Hiding()) nbCache++;
757           if (fd->Side  ()) nbFSide++;
758           if (fd->Simple()) nbFSimp++;
759         }
760         fd++;
761       }
762       
763       cout << endl;
764       cout << "Vertices  : " << setw(5) << myDS->NbVertices() << endl;
765       cout << "Edges     : " << setw(5) << myDS->NbEdges()    << " , ";
766       cout << "Selected  : " << setw(5) << nbSelEdges         << " , ";
767       cout << "Visibles  : " << setw(5) << nbVisEdges         << endl;
768       cout << "Faces     : " << setw(5) << myDS->NbFaces()    << " , ";
769       cout << "Selected  : " << setw(5) << nbSelFaces         << " , ";
770       cout << "Simple    : " << setw(5) << nbFSimp            << endl;
771       if (SideFace)
772         cout << "Side      : " << setw(5) << nbFSide            << " , ";
773       cout << "Cachantes : " << setw(5) << nbCache            << endl << endl;
774     }
775
776     Standard_Integer QWE=0,QWEQWE;
777     QWEQWE=nf/10;
778
779     if (SideFace) {
780       j = 0;
781       fd = &(myDS->FDataArray().ChangeValue(1));
782       
783       for (f = 1; f <= nf; f++) {
784         if (fd->Selected()) {
785           if (fd->Side()) {
786             if(TRACE10) { 
787               if(++QWE>QWEQWE) { 
788                 QWE=0; 
789                 cout<<"*";
790               } 
791             }
792             else {  
793               if (myDebug && TRACE) {
794                 j++;
795                 cout << " OwnHiding " << j << " of face : " << f << endl;
796               }
797             }
798             Cache.OwnHiding(f);
799           }
800         }
801         fd++;
802       }
803     }
804     
805
806 //--
807     TColStd_Array1OfInteger Val(1, nf);
808     TColStd_Array1OfReal    Size(1, nf);
809     TColStd_Array1OfInteger Index(1, nf);
810
811
812     fd = &(myDS->FDataArray().ChangeValue(1));
813     for (f = 1; f <= nf; f++) {
814       if(fd->Plane())          Val(f)=10;
815       else if(fd->Cylinder())  Val(f)=9;
816       else if(fd->Cone())      Val(f)=8;
817       else if(fd->Sphere())    Val(f)=7;
818       else if(fd->Torus())     Val(f)=6;
819       else Val(f)=0;
820       if(fd->Cut())            Val(f)-=10;
821       if(fd->Side())           Val(f)-=100;
822       if(fd->WithOutL())       Val(f)-=20;
823   
824       Size(f)=fd->Size();
825       fd++;
826     }
827
828     for(Standard_Integer tt=1;tt<=nf;tt++) { 
829       Index(tt)=tt;
830     }
831
832     //-- ======================================================================
833 /*    Standard_Boolean TriOk; //-- a refaire
834     do { 
835       Standard_Integer t,tp1;
836       TriOk=Standard_True;
837       for(t=1,tp1=2;t<nf;t++,tp1++) { 
838         if(Val(Index(t))<Val(Index(tp1))) {
839           Standard_Integer q=Index(t); Index(t)=Index(tp1); Index(tp1)=q;
840           TriOk=Standard_False;
841         }
842         else if(Val(Index(t))==Val(Index(tp1))) { 
843           if(Size(Index(t))<Size(Index(tp1))) { 
844             Standard_Integer q=Index(t); Index(t)=Index(tp1); Index(tp1)=q;
845             TriOk=Standard_False;
846           }
847         }
848       }
849     }
850     while(TriOk==Standard_False);
851 */
852     //-- ======================================================================
853     if(nf>2)  {
854       Standard_Integer i,ir,j,l;
855       Standard_Integer rra;
856       l=(nf>>1)+1;
857       ir=nf;
858       for(;;) { 
859         if(l>1) { 
860           rra=Index(--l); 
861         } 
862         else {    
863           rra=Index(ir); 
864           Index(ir)=Index(1);
865           if(--ir == 1) { 
866             Index(1)=rra;
867             break;
868           }
869         }
870         i=l;
871         j=l+l;
872         while(j<=ir) { 
873           if(j<ir) { 
874             if(Val(Index(j)) > Val(Index(j+1)))
875               j++;
876             else if(Val(Index(j)) == Val(Index(j+1))) { 
877               if(Size(Index(j)) > Size(Index(j+1))) 
878                 j++;
879             }
880           }
881           if(Val(rra) > Val(Index(j))) { 
882             Index(i)=Index(j);
883             i=j;
884             j<<=1;
885           }
886           else if((Val(rra) == Val(Index(j))) && (Size(rra) > Size(Index(j)))) { 
887             Index(i)=Index(j);
888             i=j;
889             j<<=1;
890           }
891           else {  
892             j=ir+1;
893           }
894         }
895         Index(i)=rra;
896       }
897     }
898
899     j = 0;
900     HLRBRep_Array1OfFData& FD = myDS->FDataArray();
901     
902     QWE=0;
903     for (f = 1; f <= nf; f++) {
904       Standard_Integer fi = Index(f);
905       fd=&(FD.ChangeValue(fi));
906       if (fd->Selected()) {
907         if (fd->Hiding()) {
908           if(TRACE10 && TRACE==Standard_False) { 
909             if(++QWE>QWEQWE) { 
910               cout<<".";
911               QWE=0;
912             }
913           }
914           else if (myDebug && TRACE) {
915             static int rty=0;
916             j++;
917             printf("%6d",fi); fflush(stdout);
918             if(++rty>25) { rty=0; printf("\n"); } 
919           }
920           Cache.Hide(fi,myMapOfShapeTool);
921         }
922       }
923     }
924     
925 #ifdef DEB
926     if (myDebug) {
927       fd = &(myDS->FDataArray().ChangeValue(1));
928       nbFSimp = 0;
929       
930       for (f = 1; f <= nf; f++) {
931         if (fd->Selected() && fd->Simple())
932           nbFSimp++;
933         fd++;
934       }
935
936       cout << "\n";
937       cout << "Simple Faces                  : ";
938       cout << nbFSimp  << "\n";
939       cout << "Intersections calculees       : ";
940       cout << nbCal2Intersection << "\n";
941       cout << "Intersections Ok              : ";
942       cout << nbOkIntersection << "\n";
943       cout << "Points                        : ";
944       cout << nbPtIntersection << "\n";
945       cout << "Segments                      : ";
946       cout << nbSegIntersection << "\n";
947       cout << "Classification                : ";
948       cout << nbClassification << "\n";
949       cout << "Intersections curve-surface   : ";
950       cout << nbCal3Intersection << "\n";
951       cout << endl << endl;
952     }
953 #endif
954   }
955 }
956
957 //=======================================================================
958 //function : Debug
959 //purpose  : 
960 //=======================================================================
961
962 void HLRBRep_InternalAlgo::Debug (const Standard_Boolean deb)
963 { myDebug = deb; }
964
965 //=======================================================================
966 //function : Debug
967 //purpose  : 
968 //=======================================================================
969
970 Standard_Boolean HLRBRep_InternalAlgo::Debug () const
971 { return myDebug; }
972
973 //=======================================================================
974 //function : DataStructure
975 //purpose  : 
976 //=======================================================================
977
978 Handle(HLRBRep_Data) HLRBRep_InternalAlgo::DataStructure () const
979 { return myDS; }