0022922: Clean up warnings on uninitialized / unused variables
[occt.git] / src / IntPolyh / IntPolyh_Intersection.cxx
1 // File:        IntPolyh_Intersection.cxx
2 // Created:     Wed Mar  3 11:33:51 1999
3 // Author:      Fabrice SERVANT
4 //              <fst>
5
6 //  modified by Edward AGAPOV (eap) Tue Jan 22 12:29:55 2002 (occ53)
7 //  Modified by skv - Thu Sep 25 18:24:29 2003 OCC567
8
9 #include <IntPolyh_Intersection.ixx>
10 #include <IntPolyh_SectionLine.hxx>
11 #include <IntPolyh_StartPoint.hxx>
12 #include <IntPolyh_MaillageAffinage.hxx>
13 #include <IntPolyh_Couple.hxx>
14
15 #ifdef DEB
16   # define MYDEBUG DEB 
17 #else
18   # define MYDEBUG 0
19 #endif
20
21 Standard_Integer MYDISPLAY = 0;
22 Standard_Integer MYPRINT   = 0;
23
24 # if MYDEBUG
25 //  # include "visudebug.hxx"
26 # endif
27
28
29 IntPolyh_Intersection::IntPolyh_Intersection(const Handle(Adaptor3d_HSurface)& S1,
30                                              const Handle(Adaptor3d_HSurface)& S2)
31 {
32   myNbSU1 = -1;
33   myNbSV1 = -1;
34   myNbSU2 = -1; 
35   myNbSV2 = -1; 
36   mySurf1 = S1;
37   mySurf2 = S2;
38   done = Standard_False;
39   TSectionLines.Init(1000);
40   TTangentZones.Init(10000);
41   Perform();
42 }
43
44 IntPolyh_Intersection::IntPolyh_Intersection(const Handle(Adaptor3d_HSurface)& S1,
45                                              const Standard_Integer NbSU1,
46                                              const Standard_Integer NbSV1,
47                                              const Handle(Adaptor3d_HSurface)& S2,
48                                              const Standard_Integer NbSU2,
49                                              const Standard_Integer NbSV2)
50 {
51   myNbSU1 = NbSU1;
52   myNbSV1 = NbSV1;
53   myNbSU2 = NbSU2; 
54   myNbSV2 = NbSV2; 
55   mySurf1 = S1;
56   mySurf2 = S2;
57   done = Standard_False;
58   TSectionLines.Init(1000);
59   TTangentZones.Init(10000);
60   Perform();
61 }
62
63 void IntPolyh_Intersection::Perform() { 
64
65   done = Standard_True;
66
67   Standard_Boolean startFromAdvanced = Standard_False;
68   Standard_Boolean isStdDone = Standard_False;
69   Standard_Boolean isAdvDone = Standard_False;
70   Standard_Integer nbCouplesStd = 0;
71   Standard_Integer nbCouplesAdv = 0;
72   
73   //GeomAbs_SurfaceType ST1 = mySurf1->GetType();
74   //GeomAbs_SurfaceType ST2 = mySurf2->GetType();
75
76 //   if(ST1 == GeomAbs_Torus || ST2 == GeomAbs_Torus)
77 //     startFromAdvanced = Standard_True;
78   
79   IntPolyh_PMaillageAffinage aPMaillageStd = 0;
80   IntPolyh_PMaillageAffinage aPMaillageFF = 0;
81   IntPolyh_PMaillageAffinage aPMaillageFR = 0;
82   IntPolyh_PMaillageAffinage aPMaillageRF = 0;
83   IntPolyh_PMaillageAffinage aPMaillageRR = 0;
84
85
86   if(!startFromAdvanced) {
87
88     isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
89
90     // default interference done well, use it
91     if(isStdDone && nbCouplesStd > 10) {
92       aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
93     }
94     // default interference done, but too few interferences foud;
95     // use advanced interference
96     else if(isStdDone && nbCouplesStd <= 10) {
97       isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
98       
99       // advanced interference found
100       if(isAdvDone && nbCouplesAdv > 10) {
101         aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
102         aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
103         aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
104         aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
105       }
106       else {
107         // use result of default
108         if(nbCouplesStd > 0)
109           aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
110       }
111     }
112     // default interference faild, use advanced
113     else {
114 //       isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
115       
116 //       if(isAdvDone && nbCouplesAdv > 0) {cout << "4adv done, nbc: " << nbCouplesAdv << endl;
117 //      aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
118 //      aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
119 //      aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
120 //      aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
121 //       }
122     }
123   }// start from default
124   else {
125     
126     isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
127
128     // advanced done, interference found; use it
129     if(isAdvDone) {
130
131       if(nbCouplesAdv > 0) {
132         aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
133         aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
134         aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
135         aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
136       }
137       else {
138         isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
139         if(isStdDone && nbCouplesStd > 0)
140           aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
141       }
142     }
143     else {
144       isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
145       if(isStdDone && nbCouplesStd > 0)
146         aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
147     }
148   } // start from advanced
149
150   // accept result
151   nbsectionlines = TSectionLines.NbSectionLines();
152   nbtangentzones = TTangentZones.NbTangentZones();
153
154   // clean up
155   if(aPMaillageStd) delete aPMaillageStd;
156   if(aPMaillageFF) delete aPMaillageFF;
157   if(aPMaillageFR) delete aPMaillageFR;
158   if(aPMaillageRF) delete aPMaillageRF;
159   if(aPMaillageRR) delete aPMaillageRR;
160
161   // verify
162   if(!isStdDone && !isAdvDone)
163     done = Standard_False;
164 }
165
166
167 Standard_Boolean IntPolyh_Intersection::IsDone() const {
168   return(done);
169 }
170
171
172 Standard_Integer IntPolyh_Intersection::NbSectionLines() const { 
173   return(nbsectionlines);
174 }
175
176
177 Standard_Integer IntPolyh_Intersection::NbPointsInLine(const Standard_Integer IndexLine) const { 
178   
179   return(TSectionLines[IndexLine-1].NbStartPoints());
180 }
181
182
183 Standard_Integer IntPolyh_Intersection::NbPointsInTangentZone(const Standard_Integer IndexLine) const {   
184   //-- IndexLine--;     (pas implemente) Attention : Tableaux de 0 a n-1 
185   // eap
186   // return(TTangentZones.NbTangentZones());
187   return 1;
188 }
189
190
191 Standard_Integer IntPolyh_Intersection::NbTangentZones() const { 
192   return(nbtangentzones);
193 }
194
195
196 void IntPolyh_Intersection::GetLinePoint(const Standard_Integer Indexl,
197                                  const Standard_Integer Indexp,
198                                  Standard_Real &x,
199                                  Standard_Real &y,
200                                  Standard_Real &z,
201                                  Standard_Real &u1,
202                                  Standard_Real &v1,
203                                  Standard_Real &u2,
204                                  Standard_Real &v2,
205                                  Standard_Real &incidence) const { 
206   const IntPolyh_SectionLine  &msl=TSectionLines[Indexl-1];
207   const IntPolyh_StartPoint   &sp=msl[Indexp-1];
208   x=sp.X();
209   y=sp.Y();
210   z=sp.Z();
211   u1=sp.U1();
212   v1=sp.V1();
213   u2=sp.U2();
214   v2=sp.V2();
215   incidence=sp.GetAngle();
216 }
217
218
219 void IntPolyh_Intersection::GetTangentZonePoint(const Standard_Integer Indexz,
220                                         const Standard_Integer Indexp,
221                                         Standard_Real &x,
222                                         Standard_Real &y,
223                                         Standard_Real &z,
224                                         Standard_Real &u1,
225                                         Standard_Real &v1,
226                                         Standard_Real &u2,
227                                         Standard_Real &v2) const { 
228   //--   Indexz--;    tableaux C
229   // eap
230   //const IntPolyh_StartPoint   &sp=TTangentZones[Indexp-1];
231   const IntPolyh_StartPoint   &sp=TTangentZones[Indexz-1];
232   x=sp.X();
233   y=sp.Y();
234   z=sp.Y();
235   u1=sp.U1();
236   v1=sp.V1();
237   u2=sp.U2();
238   v2=sp.V2();
239 }
240
241 //  Modified by skv - Thu Sep 25 18:07:41 2003 OCC567 Begin
242 //=======================================================================
243 //function : PerformMaillage
244 //purpose  : Computes MaillageAffinage
245 //=======================================================================
246 Standard_Boolean IntPolyh_Intersection::PerformMaillage
247                  (const Standard_Boolean            isFirstFwd,
248                   const Standard_Boolean            isSecondFwd,
249                         IntPolyh_PMaillageAffinage &theMaillageS)
250 {
251   if (myNbSU1 == -1)
252     theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, mySurf2, MYPRINT);
253   else
254     theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, myNbSU1, myNbSV1,
255                                                  mySurf2, myNbSU2, myNbSV2,
256                                                  MYPRINT);
257
258   theMaillageS->FillArrayOfPnt(1, isFirstFwd);
259   theMaillageS->FillArrayOfPnt(2, isSecondFwd);
260   
261   
262   Standard_Real xx0,yy0,zz0,xx1,yy1,zz1;
263   theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
264                           xx0, yy0, zz0, xx1, yy1, zz1);
265   
266   theMaillageS->FillArrayOfEdges(1);
267   theMaillageS->FillArrayOfEdges(2);
268
269   theMaillageS->FillArrayOfTriangles(1);
270   theMaillageS->FillArrayOfTriangles(2);
271   
272   theMaillageS->LinkEdges2Triangles();
273   
274   theMaillageS->TrianglesDeflectionsRefinementBSB();
275
276   Standard_Integer FinTTC = theMaillageS->TriangleCompare();
277
278   // if too many intersections, consider surfaces parallel (eap)
279   if(FinTTC > 200 &&
280      (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() ||
281       FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) {
282     return Standard_False;
283   }
284
285   return Standard_True;
286 }
287
288 //=======================================================================
289 //function : PerformMaillage
290 //purpose  : Computes MaillageAffinage
291 //=======================================================================
292 Standard_Boolean IntPolyh_Intersection::PerformMaillage(IntPolyh_PMaillageAffinage &theMaillageS)
293 {
294   if (myNbSU1 == -1)
295     theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, mySurf2, MYPRINT);
296   else
297     theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, myNbSU1, myNbSV1,
298                                                  mySurf2, myNbSU2, myNbSV2,
299                                                  MYPRINT);
300
301   theMaillageS->FillArrayOfPnt(1);
302   theMaillageS->FillArrayOfPnt(2);
303   
304   
305   Standard_Real xx0,yy0,zz0,xx1,yy1,zz1;
306   theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
307                           xx0, yy0, zz0, xx1, yy1, zz1);
308   
309   theMaillageS->FillArrayOfEdges(1);
310   theMaillageS->FillArrayOfEdges(2);
311
312   theMaillageS->FillArrayOfTriangles(1);
313   theMaillageS->FillArrayOfTriangles(2);
314   
315   theMaillageS->LinkEdges2Triangles();
316   
317   theMaillageS->TrianglesDeflectionsRefinementBSB();
318
319   Standard_Integer FinTTC = theMaillageS->TriangleCompare();
320
321   if( FinTTC == 0 ) {
322     Standard_Boolean myZone = Standard_True;
323     theMaillageS->SetEnlargeZone( myZone );
324     theMaillageS->FillArrayOfPnt(1);
325     theMaillageS->FillArrayOfPnt(2);
326     theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
327                             xx0, yy0, zz0, xx1, yy1, zz1);
328     theMaillageS->FillArrayOfEdges(1);
329     theMaillageS->FillArrayOfEdges(2);
330     theMaillageS->FillArrayOfTriangles(1);
331     theMaillageS->FillArrayOfTriangles(2);
332     theMaillageS->LinkEdges2Triangles();
333     theMaillageS->TrianglesDeflectionsRefinementBSB();
334     FinTTC = theMaillageS->TriangleCompare();
335     myZone = Standard_False;
336     theMaillageS->SetEnlargeZone( myZone );
337   }
338
339   // if too many intersections, consider surfaces parallel (eap)
340   if(FinTTC > 200 &&
341      (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() ||
342       FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) {
343     return Standard_False;
344   }
345
346   return Standard_True;
347 }
348
349 //=======================================================================
350 //function : MergeCouples
351 //purpose  : This method analyzes arrays to find same couples. If some 
352 //           are detected it leaves the couple in only one array 
353 //           deleting from others.
354 //=======================================================================
355
356 void IntPolyh_Intersection::MergeCouples
357                             (IntPolyh_ArrayOfCouples &anArrayFF,
358                              IntPolyh_ArrayOfCouples &anArrayFR,
359                              IntPolyh_ArrayOfCouples &anArrayRF,
360                              IntPolyh_ArrayOfCouples &anArrayRR) const
361 {
362   // Step 1: Sorting arrays.
363   IntPolyh_ArrayOfCouples *anArrays[4];
364   Standard_Integer         aNbCouples[4];
365   Standard_Integer         i;
366   IntPolyh_ArrayOfCouples *aTmpPtr;
367   Standard_Integer         aTmpNbr;
368
369   anArrays[0] = &anArrayFF;
370   anArrays[1] = &anArrayFR;
371   anArrays[2] = &anArrayRF;
372   anArrays[3] = &anArrayRR;
373
374   for (i = 0; i < 4; i++)
375     aNbCouples[i] = anArrays[i]->NbCouples();
376
377   Standard_Boolean isChanged = Standard_True;
378
379   while (isChanged) {
380     isChanged = Standard_False;
381
382     for (i = 0; i < 3; i++) {
383       if (aNbCouples[i] < aNbCouples[i + 1]) {
384         aTmpPtr           = anArrays[i];
385         anArrays[i]       = anArrays[i + 1];
386         anArrays[i + 1]   = aTmpPtr;
387         aTmpNbr           = aNbCouples[i];
388         aNbCouples[i]     = aNbCouples[i + 1];
389         aNbCouples[i + 1] = aTmpNbr;
390         isChanged         = Standard_True;
391       }
392     }
393   }
394
395   // Step 2: Searching for same couples.
396   Standard_Integer j;
397   Standard_Integer indC1;
398   Standard_Integer indC2;
399
400   for (i = 0; i < 3; i++) {
401     for (j = i + 1; j < 4; j++) {
402       for (indC1 = 1; indC1 <= aNbCouples[i]; indC1++) {
403         IntPolyh_Couple &aCouple1 = anArrays[i]->ChangeValue(indC1);
404
405         if (aCouple1.AnalyseFlagValue() == 1)
406           continue;
407
408         for (indC2 = 1; indC2 <= aNbCouples[j]; indC2++) {
409           IntPolyh_Couple &aCouple2 = anArrays[j]->ChangeValue(indC2);
410
411           if (aCouple2.AnalyseFlagValue() == 1)
412             continue;
413
414           if (aCouple1.FirstValue()  == aCouple2.FirstValue() &&
415               aCouple1.SecondValue() == aCouple2.SecondValue()) {
416             aCouple2.SetAnalyseFlag(1);
417           }
418         }
419       }
420     }
421   }
422 }
423 //  Modified by skv - Thu Sep 25 18:07:42 2003 OCC567 End
424
425 Standard_Boolean IntPolyh_Intersection::PerformStd(IntPolyh_PMaillageAffinage& MaillageS,
426                                                    Standard_Integer&           NbCouples)
427 {
428   Standard_Boolean isdone = PerformMaillage(MaillageS);
429   NbCouples = (isdone) ? (MaillageS->GetArrayOfCouples().NbCouples()) : 0;
430   return isdone;
431 }
432
433 Standard_Boolean IntPolyh_Intersection::PerformAdv(IntPolyh_PMaillageAffinage& MaillageFF,
434                                                    IntPolyh_PMaillageAffinage& MaillageFR,
435                                                    IntPolyh_PMaillageAffinage& MaillageRF,
436                                                    IntPolyh_PMaillageAffinage& MaillageRR,
437                                                    Standard_Integer&           NbCouples)
438 {
439   Standard_Boolean isdone = Standard_True;
440   NbCouples = 0;
441
442   if(!PerformMaillage(Standard_True,Standard_False,MaillageFR) ||
443      !PerformMaillage(Standard_False,Standard_True,MaillageRF) ||
444      !PerformMaillage(Standard_True,Standard_True,MaillageFF)  ||
445      !PerformMaillage(Standard_False,Standard_False,MaillageRR) )
446     isdone = Standard_False; 
447
448   if(isdone) {
449     NbCouples = MaillageFF->GetArrayOfCouples().NbCouples() +
450       MaillageFR->GetArrayOfCouples().NbCouples() +
451         MaillageRF->GetArrayOfCouples().NbCouples() +
452           MaillageRR->GetArrayOfCouples().NbCouples();
453
454     if(NbCouples > 0)
455       MergeCouples(MaillageFF->GetArrayOfCouples(),MaillageFR->GetArrayOfCouples(),
456                    MaillageRF->GetArrayOfCouples(),MaillageRR->GetArrayOfCouples());
457   }
458   return isdone;
459 }