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