69c26a2ca03dbec9250a0a597cdfed3f57fb23a4
[occt.git] / src / HLRAlgo / HLRAlgo_PolyInternalData.cxx
1 // Created on: 1995-07-11
2 // Created by: Christophe MARION
3 // Copyright (c) 1995-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_BiPoint.hxx>
19 #include <HLRAlgo_PolyInternalData.hxx>
20 #include <Standard_Stream.hxx>
21 #include <Standard_Type.hxx>
22
23 IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
24
25 #define Tri1Node1 ((Standard_Integer*)Tri1Indices)[0]
26 #define Tri1Node2 ((Standard_Integer*)Tri1Indices)[1]
27 #define Tri1Node3 ((Standard_Integer*)Tri1Indices)[2]
28 #define Tri1Flags ((Standard_Integer*)Tri1Indices)[3]
29
30 #define Tri2Node1 ((Standard_Integer*)Tri2Indices)[0]
31 #define Tri2Node2 ((Standard_Integer*)Tri2Indices)[1]
32 #define Tri2Node3 ((Standard_Integer*)Tri2Indices)[2]
33 #define Tri2Flags ((Standard_Integer*)Tri2Indices)[3]
34
35 #define Seg1LstSg1 ((Standard_Integer*)Seg1Indices)[0]
36 #define Seg1LstSg2 ((Standard_Integer*)Seg1Indices)[1]
37 #define Seg1NxtSg1 ((Standard_Integer*)Seg1Indices)[2]
38 #define Seg1NxtSg2 ((Standard_Integer*)Seg1Indices)[3]
39 #define Seg1Conex1 ((Standard_Integer*)Seg1Indices)[4]
40 #define Seg1Conex2 ((Standard_Integer*)Seg1Indices)[5]
41
42 #define Seg2LstSg1 ((Standard_Integer*)Seg2Indices)[0]
43 #define Seg2LstSg2 ((Standard_Integer*)Seg2Indices)[1]
44 #define Seg2NxtSg1 ((Standard_Integer*)Seg2Indices)[2]
45 #define Seg2NxtSg2 ((Standard_Integer*)Seg2Indices)[3]
46 #define Seg2Conex1 ((Standard_Integer*)Seg2Indices)[4]
47 #define Seg2Conex2 ((Standard_Integer*)Seg2Indices)[5]
48
49 #define Nod1NdSg ((Standard_Integer*)Nod1Indices)[0]
50 #define Nod1Flag ((Standard_Integer*)Nod1Indices)[1]
51 #define Nod1Edg1 ((Standard_Integer*)Nod1Indices)[2]
52 #define Nod1Edg2 ((Standard_Integer*)Nod1Indices)[3]
53
54 #define Nod1PntX ((Standard_Real*)Nod1RValues)[ 0]
55 #define Nod1PntY ((Standard_Real*)Nod1RValues)[ 1]
56 #define Nod1PntZ ((Standard_Real*)Nod1RValues)[ 2]
57 #define Nod1PntU ((Standard_Real*)Nod1RValues)[ 3]
58 #define Nod1PntV ((Standard_Real*)Nod1RValues)[ 4]
59 #define Nod1NrmX ((Standard_Real*)Nod1RValues)[ 5]
60 #define Nod1NrmY ((Standard_Real*)Nod1RValues)[ 6]
61 #define Nod1NrmZ ((Standard_Real*)Nod1RValues)[ 7]
62 #define Nod1PCu1 ((Standard_Real*)Nod1RValues)[ 8]
63 #define Nod1PCu2 ((Standard_Real*)Nod1RValues)[ 9]
64 #define Nod1Scal ((Standard_Real*)Nod1RValues)[10]
65
66 #define Nod2NdSg ((Standard_Integer*)Nod2Indices)[0]
67 #define Nod2Flag ((Standard_Integer*)Nod2Indices)[1]
68 #define Nod2Edg1 ((Standard_Integer*)Nod2Indices)[2]
69 #define Nod2Edg2 ((Standard_Integer*)Nod2Indices)[3]
70
71 #define Nod2PntX ((Standard_Real*)Nod2RValues)[ 0]
72 #define Nod2PntY ((Standard_Real*)Nod2RValues)[ 1]
73 #define Nod2PntZ ((Standard_Real*)Nod2RValues)[ 2]
74 #define Nod2PntU ((Standard_Real*)Nod2RValues)[ 3]
75 #define Nod2PntV ((Standard_Real*)Nod2RValues)[ 4]
76 #define Nod2NrmX ((Standard_Real*)Nod2RValues)[ 5]
77 #define Nod2NrmY ((Standard_Real*)Nod2RValues)[ 6]
78 #define Nod2NrmZ ((Standard_Real*)Nod2RValues)[ 7]
79 #define Nod2PCu1 ((Standard_Real*)Nod2RValues)[ 8]
80 #define Nod2PCu2 ((Standard_Real*)Nod2RValues)[ 9]
81 #define Nod2Scal ((Standard_Real*)Nod2RValues)[10]
82
83 #define Nod3NdSg ((Standard_Integer*)Nod3Indices)[0]
84 #define Nod3Flag ((Standard_Integer*)Nod3Indices)[1]
85 #define Nod3Edg1 ((Standard_Integer*)Nod3Indices)[2]
86 #define Nod3Edg2 ((Standard_Integer*)Nod3Indices)[3]
87
88 #define Nod3PntX ((Standard_Real*)Nod3RValues)[ 0]
89 #define Nod3PntY ((Standard_Real*)Nod3RValues)[ 1]
90 #define Nod3PntZ ((Standard_Real*)Nod3RValues)[ 2]
91 #define Nod3PntU ((Standard_Real*)Nod3RValues)[ 3]
92 #define Nod3PntV ((Standard_Real*)Nod3RValues)[ 4]
93 #define Nod3NrmX ((Standard_Real*)Nod3RValues)[ 5]
94 #define Nod3NrmY ((Standard_Real*)Nod3RValues)[ 6]
95 #define Nod3NrmZ ((Standard_Real*)Nod3RValues)[ 7]
96 #define Nod3PCu1 ((Standard_Real*)Nod3RValues)[ 8]
97 #define Nod3PCu2 ((Standard_Real*)Nod3RValues)[ 9]
98 #define Nod3Scal ((Standard_Real*)Nod3RValues)[10]
99
100 #define Nod4NdSg ((Standard_Integer*)Nod4Indices)[0]
101 #define Nod4Flag ((Standard_Integer*)Nod4Indices)[1]
102 #define Nod4Edg1 ((Standard_Integer*)Nod4Indices)[2]
103 #define Nod4Edg2 ((Standard_Integer*)Nod4Indices)[3]
104
105 #define Nod4PntX ((Standard_Real*)Nod4RValues)[ 0]
106 #define Nod4PntY ((Standard_Real*)Nod4RValues)[ 1]
107 #define Nod4PntZ ((Standard_Real*)Nod4RValues)[ 2]
108 #define Nod4PntU ((Standard_Real*)Nod4RValues)[ 3]
109 #define Nod4PntV ((Standard_Real*)Nod4RValues)[ 4]
110 #define Nod4NrmX ((Standard_Real*)Nod4RValues)[ 5]
111 #define Nod4NrmY ((Standard_Real*)Nod4RValues)[ 6]
112 #define Nod4NrmZ ((Standard_Real*)Nod4RValues)[ 7]
113 #define Nod4PCu1 ((Standard_Real*)Nod4RValues)[ 8]
114 #define Nod4PCu2 ((Standard_Real*)Nod4RValues)[ 9]
115 #define Nod4Scal ((Standard_Real*)Nod4RValues)[10]
116 #ifdef OCCT_DEBUG
117 static Standard_Integer TRACE = Standard_False;
118 static Standard_Integer ERROR = Standard_False;
119 #endif
120 //=======================================================================
121 //function : PolyInternalData
122 //purpose  : 
123 //=======================================================================
124
125 HLRAlgo_PolyInternalData::HLRAlgo_PolyInternalData
126 (const Standard_Integer nbNod,
127  const Standard_Integer nbTri) :
128  myNbTData(nbTri),
129  myNbPISeg(0),
130  myNbPINod(nbNod),
131  myMxTData(nbTri),
132  myMxPINod(nbNod),
133  myIntOutL(Standard_False),
134  myPlanar(Standard_False)
135 {
136   Standard_Integer i;
137   myMxPISeg = 2 + (3 * nbTri + nbNod) / 2;
138   myTData = new HLRAlgo_HArray1OfTData(0,myMxTData);
139   myPISeg = new HLRAlgo_HArray1OfPISeg(0,myMxPISeg);
140   myPINod = new HLRAlgo_HArray1OfPINod(0,myMxPINod);
141   
142   HLRAlgo_Array1OfPINod& PINod = myPINod->ChangeArray1();
143   Handle(HLRAlgo_PolyInternalNode)* NN = &(PINod.ChangeValue(1));
144 //  Standard_Address Nod1Indices;
145   
146   for (i = 1; i <= myMxPINod; i++) {
147     *NN = new HLRAlgo_PolyInternalNode();
148     NN++;
149   }
150 }
151
152 //=======================================================================
153 //function : UpdateLinks
154 //purpose  : 
155 //=======================================================================
156
157 void HLRAlgo_PolyInternalData::UpdateLinks
158 (Standard_Address& TData,
159  Standard_Address& PISeg,
160  Standard_Address& PINod)
161 {
162   Standard_Integer i,n1,n2;
163   Standard_Integer find,iiii,icsv = 0;
164   Standard_Address A1,A2,A3,Nod1Indices,Nod2Indices,Seg2Indices = NULL,Tri2Indices;
165   Standard_Boolean newSeg = Standard_False;
166   HLRAlgo_TriangleData* TD =
167     &(((HLRAlgo_Array1OfTData*)TData)->ChangeValue(1));
168   
169   for (i = 1; i <= myNbTData; i++) {
170     Tri2Indices = TD->Indices();
171     A1 = ((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(Tri2Node1)->Indices();
172     A2 = ((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(Tri2Node2)->Indices();
173     A3 = ((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(Tri2Node3)->Indices();
174     n1 = Tri2Node1;
175     n2 = Tri2Node2;
176     Nod1Indices = A1;
177     Nod2Indices = A2;
178     newSeg = Standard_False;
179     if (Nod1NdSg == 0 && Nod2NdSg == 0) {
180       newSeg = Standard_True;
181       myNbPISeg++;
182       Nod1NdSg = myNbPISeg;
183       Nod2NdSg = myNbPISeg;
184     }
185     else {
186       iiii = Nod1NdSg;
187       if (iiii != 0) {
188         find = 0;
189         
190         while (iiii != 0 && find == 0) {
191           Seg2Indices =
192             ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
193           if (Seg2LstSg1 == n1) {
194             if (Seg2LstSg2 == n2) find = iiii;
195             else                  iiii = Seg2NxtSg1;
196             icsv = 1;
197           }
198           else {
199             if (Seg2LstSg1 == n2) find = iiii;
200             else                  iiii = Seg2NxtSg2;
201             icsv = 2;
202           }
203         }
204         if (find == 0) {
205           newSeg = Standard_True;
206           myNbPISeg++;
207           if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
208           else           Seg2NxtSg2 = myNbPISeg;
209         }
210         else Seg2Conex2 = i;
211       }
212       else {
213         newSeg = Standard_True;
214         myNbPISeg++;
215         Nod1NdSg = myNbPISeg;
216       }
217       if (newSeg) {
218         iiii = Nod2NdSg;
219         if (iiii != 0) {
220           
221           while (iiii != 0) {
222             Seg2Indices =
223               ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
224             if (Seg2LstSg1 == n2) { icsv = 1; iiii = Seg2NxtSg1; }
225             else                  { icsv = 2; iiii = Seg2NxtSg2; }
226           }
227           if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
228           else           Seg2NxtSg2 = myNbPISeg;
229         }
230         else Nod2NdSg = myNbPISeg;
231       }
232     }
233     if (newSeg) {
234       Seg2Indices =
235         ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(myNbPISeg).Indices();
236       Seg2LstSg1 = n1;
237       Seg2LstSg2 = n2;
238       Seg2Conex1 = i;
239       Seg2Conex2 = 0;
240       Seg2NxtSg1 = 0;
241       Seg2NxtSg2 = 0;
242     }
243     
244     n1 = Tri2Node2;
245     n2 = Tri2Node3;
246     Nod1Indices = A2;
247     Nod2Indices = A3;
248     newSeg = Standard_False;
249     if (Nod1NdSg == 0 && Nod2NdSg == 0) {
250       newSeg = Standard_True;
251       myNbPISeg++;
252       Nod1NdSg = myNbPISeg;
253       Nod2NdSg = myNbPISeg;
254     }
255     else {
256       iiii = Nod1NdSg;
257       if (iiii != 0) {
258         find = 0;
259         
260         while (iiii != 0 && find == 0) {
261           Seg2Indices =
262             ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
263           if (Seg2LstSg1 == n1) {
264             if (Seg2LstSg2 == n2) find = iiii;
265             else                  iiii = Seg2NxtSg1;
266             icsv = 1;
267           }
268           else {
269             if (Seg2LstSg1 == n2) find = iiii;
270             else                  iiii = Seg2NxtSg2;
271             icsv = 2;
272           }
273         }
274         if (find == 0) {
275           newSeg = Standard_True;
276           myNbPISeg++;
277           if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
278           else           Seg2NxtSg2 = myNbPISeg;
279         }
280         else Seg2Conex2 = i;
281       }
282       else {
283         newSeg = Standard_True;
284         myNbPISeg++;
285         Nod1NdSg = myNbPISeg;
286       }
287       if (newSeg) {
288         iiii = Nod2NdSg;
289         if (iiii != 0) {
290           
291           while (iiii != 0) {
292             Seg2Indices =
293               ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
294             if (Seg2LstSg1 == n2) { icsv = 1; iiii = Seg2NxtSg1; }
295             else                  { icsv = 2; iiii = Seg2NxtSg2; }
296           }
297           if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
298           else           Seg2NxtSg2 = myNbPISeg;
299         }
300         else Nod2NdSg = myNbPISeg;
301       }
302     }
303     if (newSeg) {
304       Seg2Indices =
305         ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(myNbPISeg).Indices();
306       Seg2LstSg1 = n1;
307       Seg2LstSg2 = n2;
308       Seg2Conex1 = i;
309       Seg2Conex2 = 0;
310       Seg2NxtSg1 = 0;
311       Seg2NxtSg2 = 0;
312     }
313     
314     n1 = Tri2Node3;
315     n2 = Tri2Node1;
316     Nod1Indices = A3;
317     Nod2Indices = A1;
318     newSeg = Standard_False;
319     if (Nod1NdSg == 0 && Nod2NdSg == 0) {
320       newSeg = Standard_True;
321       myNbPISeg++;
322       Nod1NdSg = myNbPISeg;
323       Nod2NdSg = myNbPISeg;
324     }
325     else {
326       iiii = Nod1NdSg;
327       if (iiii != 0) {
328         find = 0;
329         
330         while (iiii != 0 && find == 0) {
331           Seg2Indices =
332             ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
333           if (Seg2LstSg1 == n1) {
334             if (Seg2LstSg2 == n2) find = iiii;
335             else                  iiii = Seg2NxtSg1;
336             icsv = 1;
337           }
338           else {
339             if (Seg2LstSg1 == n2) find = iiii;
340             else                  iiii = Seg2NxtSg2;
341             icsv = 2;
342           }
343         }
344         if (find == 0) {
345           newSeg = Standard_True;
346           myNbPISeg++;
347           if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
348           else           Seg2NxtSg2 = myNbPISeg;
349         }
350         else Seg2Conex2 = i;
351       }
352       else {
353         newSeg = Standard_True;
354         myNbPISeg++;
355         Nod1NdSg = myNbPISeg;
356       }
357       if (newSeg) {
358         iiii = Nod2NdSg;
359         if (iiii != 0) {
360           
361           while (iiii != 0) {
362             Seg2Indices =
363               ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
364             if (Seg2LstSg1 == n2) { icsv = 1; iiii = Seg2NxtSg1; }
365             else                  { icsv = 2; iiii = Seg2NxtSg2; }
366           }
367           if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
368           else           Seg2NxtSg2 = myNbPISeg;
369         }
370         else Nod2NdSg = myNbPISeg;
371       }
372     }
373     if (newSeg) {
374       Seg2Indices =
375         ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(myNbPISeg).Indices();
376       Seg2LstSg1 = n1;
377       Seg2LstSg2 = n2;
378       Seg2Conex1 = i;
379       Seg2Conex2 = 0;
380       Seg2NxtSg1 = 0;
381       Seg2NxtSg2 = 0;
382     }
383     TD++;
384   }
385 }
386
387 //=======================================================================
388 //function : AddNode
389 //purpose  : 
390 //=======================================================================
391
392 Standard_Integer
393 HLRAlgo_PolyInternalData::AddNode (const Standard_Address Nod1RValues,
394                                    const Standard_Address Nod2RValues,
395                                    Standard_Address& PINod1,
396                                    Standard_Address& PINod2,
397                                    const Standard_Real coef1,
398                                    const Standard_Real X3,
399                                    const Standard_Real Y3,
400                                    const Standard_Real Z3)
401 {
402   Standard_Real coef2 = 1 - coef1;
403   IncPINod(PINod1,PINod2);
404   Standard_Integer ip3 = myNbPINod;
405   Handle(HLRAlgo_PolyInternalNode)* pip3 = 
406     &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip3));
407   *pip3 = new HLRAlgo_PolyInternalNode();
408   const Standard_Address Nod3RValues = (*pip3)->RValues();
409   const Standard_Address Nod3Indices = (*pip3)->Indices();
410   Nod3NdSg = 0;
411   Nod3Flag = 0;
412   Nod3PntX = X3;
413   Nod3PntY = Y3;
414   Nod3PntZ = Z3;
415   Nod3PntU = Nod1PntU * coef2 + Nod2PntU * coef1;
416   Nod3PntV = Nod1PntV * coef2 + Nod2PntV * coef1; 
417   Nod3Scal = Nod1Scal * coef2 + Nod2Scal * coef1;
418   Standard_Real x = Nod1NrmX * coef2 + Nod2NrmX * coef1;
419   Standard_Real y = Nod1NrmY * coef2 + Nod2NrmY * coef1;
420   Standard_Real z = Nod1NrmZ * coef2 + Nod2NrmZ * coef1;
421   Standard_Real d = sqrt(x * x + y * y + z * z);
422
423   if (d > 0) {
424     Nod3NrmX = x / d;
425     Nod3NrmY = y / d;
426     Nod3NrmZ = z / d;
427   }
428   else {
429     Nod3NrmX = 1;
430     Nod3NrmY = 0;
431     Nod3NrmZ = 0;
432 #ifdef OCCT_DEBUG
433     if (ERROR)
434       cout << "HLRAlgo_PolyInternalData::AddNode" << endl;
435 #endif
436   }
437   return ip3;
438 }
439
440 //=======================================================================
441 //function : UpdateLinks
442 //purpose  : 
443 //=======================================================================
444
445 void
446 HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
447                                        const Standard_Integer ip2,
448                                        const Standard_Integer ip3,
449                                        Standard_Address& TData1,
450                                        Standard_Address& TData2,
451                                        Standard_Address& PISeg1,
452                                        Standard_Address& PISeg2,
453                                        Standard_Address& PINod1,
454                                        Standard_Address& )
455 {
456   Standard_Integer find,iiii,iisv,icsv,iip2 =0,cnx1 =0,cnx2 =0;
457   Standard_Address Seg1Indices,Seg2Indices = NULL;
458   Seg1Indices = 0;
459   find = 0;
460   iisv = 0;
461   icsv = 0;
462   IncPISeg(PISeg1,PISeg2);
463   IncPISeg(PISeg1,PISeg2);
464   IncPISeg(PISeg1,PISeg2);
465   myNbPISeg--;
466   myNbPISeg--;
467   IncTData(TData1,TData2);
468   IncTData(TData1,TData2);
469   myNbTData--;
470   myNbTData--;
471   Standard_Address Nod1Indices =
472     ((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip1)->Indices();
473   Standard_Address Nod2Indices =
474     ((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip2)->Indices();
475   Standard_Address Nod3Indices =
476     ((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip3)->Indices();
477   iiii = Nod2NdSg;
478   
479   while (iiii != 0 && find == 0) {
480     Seg2Indices =
481       ((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(iiii).Indices();
482     if (Seg2LstSg1 == ip2) {
483       if (Seg2LstSg2 == ip1) {
484         find = iiii;
485         cnx1 = Seg2Conex1;
486         cnx2 = Seg2Conex2;
487         Seg2LstSg1 = ip3;
488         iip2 = Seg2NxtSg1;
489         Seg2NxtSg1 = myNbPISeg;
490         if      (iisv == 0) Nod2NdSg   = myNbPISeg;
491         else if (icsv == 1) Seg1NxtSg1 = myNbPISeg;
492         else                Seg1NxtSg2 = myNbPISeg;
493       }
494       else { 
495         iisv = iiii;
496         icsv = 1;
497       }
498       iiii = Seg2NxtSg1;
499     }
500     else {
501       if (Seg2LstSg1 == ip1) {
502         find = iiii;
503         cnx1 = Seg2Conex1;
504         cnx2 = Seg2Conex2;
505         Seg2LstSg2 = ip3;
506         iip2 = Seg2NxtSg2;
507         Seg2NxtSg2 = myNbPISeg;
508         if      (iisv == 0) Nod2NdSg   = myNbPISeg;
509         else if (icsv == 1) Seg1NxtSg1 = myNbPISeg;
510         else                Seg1NxtSg2 = myNbPISeg;
511       }
512       else { 
513         iisv = iiii;
514         icsv = 2;
515       }
516       iiii = Seg2NxtSg2;
517     }
518     Seg1Indices = Seg2Indices;
519   }
520   if (find == 0) {
521     myNbPISeg--;
522 #ifdef OCCT_DEBUG
523     if (ERROR) {
524       cout << "HLRAlgo_PolyInternalData::UpdateLinks : segment error";
525       cout << endl;
526     }
527 #endif
528   }
529   else {
530     Seg2Indices =
531       ((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(myNbPISeg).Indices();
532     Seg2NxtSg1 = 0;
533     Seg2NxtSg2 = iip2;
534     Seg2LstSg1 = ip3;
535     Seg2LstSg2 = ip2;
536     Seg2Conex1 = cnx1;
537     Seg2Conex2 = cnx2;
538     Nod3NdSg   = find;
539
540     Standard_Integer iOld,iNew,iTr,skip,ip4,itpk[2];
541     Standard_Integer n1,n2,n3,nOld[3],nNew[3],New[4];
542     New[0] = cnx1;
543     New[2] = myNbTData + 1;
544     if (cnx2 == 0) {
545       New[1] = 0;
546       New[3] = 0;
547     }
548     else {
549       New[1] = cnx2;
550       New[3] = myNbTData + 2;
551     }
552     
553     for (skip = 0; skip <= 1; skip++) {
554       iOld = New[skip];
555       iNew = New[skip + 2];
556       if (iOld != 0) {
557         Standard_Address Tri1Indices =
558           ((HLRAlgo_Array1OfTData*)TData1)->ChangeValue(iOld).Indices();
559         Standard_Address Tri2Indices =
560           ((HLRAlgo_Array1OfTData*)TData1)->ChangeValue(iNew).Indices();
561         n1 = Tri1Node1;
562         n2 = Tri1Node2;
563         n3 = Tri1Node3;
564         nOld[0] = n1;
565         nOld[1] = n2;
566         nOld[2] = n3;
567         nNew[0] = n1;
568         nNew[1] = n2;
569         nNew[2] = n3;
570         Standard_Boolean found = Standard_False;
571         if      (n1 == ip1 && n2 == ip2) {
572           found = Standard_True;
573           nOld[1] = ip3;
574           nNew[0] = ip3;
575           itpk[skip] = n3;
576         }
577         else if (n1 == ip2 && n2 == ip1) {
578           found = Standard_True;
579           nOld[0] = ip3;
580           nNew[1] = ip3;
581           itpk[skip] = n3;
582         }
583         else if (n2 == ip1 && n3 == ip2) {
584           found = Standard_True;
585           nOld[2] = ip3;
586           nNew[1] = ip3;
587           itpk[skip] = n1;
588         }
589         else if (n2 == ip2 && n3 == ip1) {
590           found = Standard_True;
591           nOld[1] = ip3;
592           nNew[2] = ip3;
593           itpk[skip] = n1;
594         }
595         else if (n3 == ip1 && n1 == ip2) {
596           found = Standard_True;
597           nOld[0] = ip3;
598           nNew[2] = ip3;
599           itpk[skip] = n2;
600         }
601         else if (n3 == ip2 && n1 == ip1) {
602           found = Standard_True;
603           nOld[2] = ip3;
604           nNew[0] = ip3;
605           itpk[skip] = n2;
606         }
607         if (found) {
608           myNbTData++;
609           ip4 = itpk[skip];
610           Standard_Address Nod4Indices =
611             ((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip4)->Indices();
612           Tri1Node1 = nOld[0];
613           Tri1Node2 = nOld[1];
614           Tri1Node3 = nOld[2];
615           Tri2Node1 = nNew[0];
616           Tri2Node2 = nNew[1];
617           Tri2Node3 = nNew[2];
618           Tri2Flags = Tri1Flags;
619           myNbPISeg++;
620           Seg2Indices =
621             ((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(myNbPISeg).Indices();
622           Seg2LstSg1 = ip3;
623           Seg2LstSg2 = ip4;
624           Seg2NxtSg1 = Nod3NdSg;
625           Seg2NxtSg2 = Nod4NdSg;
626           Seg2Conex1 = iOld;
627           Seg2Conex2 = iNew;
628           Nod3NdSg   = myNbPISeg;
629           Nod4NdSg   = myNbPISeg;
630         }
631 #ifdef OCCT_DEBUG
632         else if (ERROR) {
633           cout << "HLRAlgo_PolyInternalData::UpdateLinks : triangle error ";
634           cout << endl;
635         }
636 #endif
637       }
638     }
639     
640     for (iTr = 0; iTr <= 3; iTr++) {
641       iNew = New [iTr];
642       if (iTr < 2) skip = iTr;
643       else         skip = iTr - 2;
644       iOld = New [skip];
645       ip4  = itpk[skip];
646       if (iNew != 0) {
647         Standard_Address Tri2Indices =
648           ((HLRAlgo_Array1OfTData*)TData1)->ChangeValue(iNew).Indices();
649         n1 = Tri2Node1;
650         n2 = Tri2Node2;
651         n3 = Tri2Node3; 
652         
653         if (!((n1 == ip3 && n2 == ip4) ||
654               (n2 == ip3 && n1 == ip4))) {
655           Standard_Boolean found = Standard_False;
656           Nod1Indices =
657             ((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(n1)->Indices();
658           iiii = Nod1NdSg;
659           
660           while (iiii != 0 && !found) {
661             Seg2Indices =
662               ((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(iiii).Indices();
663             if (Seg2LstSg1 == n1) {
664               if (Seg2LstSg2 == n2) {
665                 found = Standard_True;
666                 if      (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
667                 else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
668               }
669               else iiii = Seg2NxtSg1;
670             }
671             else {
672               if (Seg2LstSg1 == n2) {
673                 found = Standard_True;
674                 if      (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
675                 else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
676               }
677               else iiii = Seg2NxtSg2;
678             }
679           }
680         }
681         
682         if (!((n2 == ip3 && n3 == ip4) ||
683               (n3 == ip3 && n2 == ip4))) {
684           Standard_Boolean found = Standard_False;
685           Nod1Indices =
686             ((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(n2)->Indices();
687           iiii = Nod1NdSg;
688           
689           while (iiii != 0 && !found) {
690             Seg2Indices =
691               ((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(iiii).Indices();
692             if (Seg2LstSg1 == n2) {
693               if (Seg2LstSg2 == n3) {
694                 found = Standard_True;
695                 if      (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
696                 else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
697               }
698               else iiii = Seg2NxtSg1;
699             }
700             else {
701               if (Seg2LstSg1 == n3) {
702                 found = Standard_True;
703                 if      (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
704                 else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
705               }
706               else iiii = Seg2NxtSg2;
707             }
708           }
709         }
710
711         if (!((n3 == ip3 && n1 == ip4) ||
712               (n1 == ip3 && n3 == ip4))) {
713           Standard_Boolean found = Standard_False;
714           Nod1Indices =
715             ((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(n3)->Indices();
716           iiii = Nod1NdSg;
717           
718           while (iiii != 0 && !found) {
719             Seg2Indices =
720               ((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(iiii).Indices();
721             if (Seg2LstSg1 == n3) {
722               if (Seg2LstSg2 == n1) {
723                 found = Standard_True;
724                 if      (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
725                 else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
726               }
727               else iiii = Seg2NxtSg1;
728             }
729             else {
730               if (Seg2LstSg1 == n1) {
731                 found = Standard_True;
732                 if      (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
733                 else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
734               }
735               else iiii = Seg2NxtSg2;
736             }
737           }
738         }
739       }
740     }
741   }
742 }
743
744 //=======================================================================
745 //function : Dump
746 //purpose  : 
747 //=======================================================================
748
749 void HLRAlgo_PolyInternalData::Dump () const
750 {
751   Standard_Integer i;//,i1,i2,i3;
752   Standard_Address Seg2Indices;
753   Standard_Address TData = &myTData->ChangeArray1();
754   Standard_Address PISeg = &myPISeg->ChangeArray1();
755   Standard_Address PINod = &myPINod->ChangeArray1();
756   
757   for (i = 1; i <= myNbPINod; i++) {
758     const Handle(HLRAlgo_PolyInternalNode)* pi =
759       &(((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(i));
760     Standard_Address Nod1Indices = (*pi)->Indices();
761     Standard_Address Nod1RValues = (*pi)->RValues();
762     cout << "Node " << setw(6) << i << " : ";
763     cout << setw(6) << Nod1NdSg;
764     cout << setw(20)<< Nod1PntX;
765     cout << setw(20)<< Nod1PntY;
766     cout << setw(20)<< Nod1PntZ;
767     cout << endl;
768   }
769
770   for (i = 1; i <= myNbPISeg; i++) {
771     Seg2Indices =
772       ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(i).Indices();
773     cout << "Segment " << setw(6) << i << " : ";
774     cout << setw(6) << Seg2LstSg1;
775     cout << setw(6) << Seg2LstSg2;
776     cout << setw(6) << Seg2NxtSg1;
777     cout << setw(6) << Seg2NxtSg2;
778     cout << setw(6) << Seg2Conex1;
779     cout << setw(6) << Seg2Conex2;
780     cout << endl;
781   }
782
783   for (i = 1; i <= myNbTData; i++) {
784     Standard_Address Tri2Indices =
785       ((HLRAlgo_Array1OfTData*)TData)->ChangeValue(i).Indices();
786     cout << "Triangle " << setw(6) << i << " : ";
787     cout << setw(6) << Tri2Node1;
788     cout << setw(6) << Tri2Node2;
789     cout << setw(6) << Tri2Node3;
790     cout << endl;
791   }
792 }
793
794 //=======================================================================
795 //function : IncTData
796 //purpose  : 
797 //=======================================================================
798
799 void HLRAlgo_PolyInternalData::
800 IncTData (Standard_Address& TData1,
801           Standard_Address& TData2)
802 {
803   if (myNbTData >= myMxTData) {
804 #ifdef OCCT_DEBUG
805     if (TRACE) 
806       cout << "HLRAlgo_PolyInternalData::IncTData : " << myMxTData << endl;
807 #endif
808     Standard_Integer i,j,k;
809     j = myMxTData;
810     k = 2 * j;
811
812     Handle(HLRAlgo_HArray1OfTData) NwTData =
813       new HLRAlgo_HArray1OfTData(0,k);
814     HLRAlgo_Array1OfTData& oTData = myTData->ChangeArray1();
815     HLRAlgo_Array1OfTData& nTData = NwTData->ChangeArray1();
816     HLRAlgo_TriangleData* OT = &(oTData.ChangeValue(1));
817     HLRAlgo_TriangleData* NT = &(nTData.ChangeValue(1));
818     Standard_Address Tri1Indices,Tri2Indices;
819
820     for (i = 1; i <= j; i++) {
821       Tri1Indices = OT->Indices();
822       Tri2Indices = NT->Indices();
823       Tri2Node1 = Tri1Node1;
824       Tri2Node2 = Tri1Node2;
825       Tri2Node3 = Tri1Node3;
826       Tri2Flags = Tri1Flags;
827       OT++;
828       NT++;
829     }
830     myMxTData = k;
831     myTData  = NwTData;
832     if (TData1 == TData2) {
833       TData1 = &nTData;
834       TData2 = TData1;
835     }
836     else {
837       TData1 = &nTData;
838     }
839   }
840   myNbTData++;
841 }
842
843 //=======================================================================
844 //function : IncPISeg
845 //purpose  : 
846 //=======================================================================
847
848 void HLRAlgo_PolyInternalData::
849 IncPISeg (Standard_Address& PISeg1,
850           Standard_Address& PISeg2)
851
852   if (myNbPISeg >= myMxPISeg) {
853 #ifdef OCCT_DEBUG
854     if (TRACE) 
855       cout << "HLRAlgo_PolyInternalData::IncPISeg : " << myMxPISeg << endl;
856 #endif
857     Standard_Integer i,j,k;
858     j = myMxPISeg;
859     k = 2 * j;
860     Handle(HLRAlgo_HArray1OfPISeg) NwPISeg =
861       new HLRAlgo_HArray1OfPISeg(0,k);
862     HLRAlgo_Array1OfPISeg& oPISeg = myPISeg->ChangeArray1();
863     HLRAlgo_Array1OfPISeg& nPISeg = NwPISeg->ChangeArray1();
864     HLRAlgo_PolyInternalSegment* OS = &(oPISeg.ChangeValue(1));
865     HLRAlgo_PolyInternalSegment* NS = &(nPISeg.ChangeValue(1));
866     Standard_Address Seg1Indices,Seg2Indices;
867
868     for (i = 1; i <= j; i++) {
869       Seg1Indices = OS->Indices();
870       Seg2Indices = NS->Indices();
871       Seg2LstSg1 = Seg1LstSg1;
872       Seg2LstSg2 = Seg1LstSg2;
873       Seg2NxtSg1 = Seg1NxtSg1;
874       Seg2NxtSg2 = Seg1NxtSg2;
875       Seg2Conex1 = Seg1Conex1;
876       Seg2Conex2 = Seg1Conex2;
877       OS++;
878       NS++;
879     }
880     myMxPISeg = k;
881     myPISeg = NwPISeg;
882     if (PISeg1 == PISeg2) {
883       PISeg1 = &nPISeg;
884       PISeg2 = PISeg1;
885     }
886     else {
887       PISeg1 = &nPISeg;
888     }
889   }
890   myNbPISeg++;
891 }
892
893 //=======================================================================
894 //function : IncPINod
895 //purpose  : 
896 //=======================================================================
897
898 void HLRAlgo_PolyInternalData::
899 IncPINod (Standard_Address& PINod1,
900           Standard_Address& PINod2)
901 {
902   if (myNbPINod >= myMxPINod) {
903 #ifdef OCCT_DEBUG
904     if (TRACE) 
905       cout << "HLRAlgo_PolyInternalData::IncPINod : " << myMxPINod << endl;
906 #endif
907     Standard_Integer i,j,k;
908 //    Standard_Address Nod1Indices;
909     j = myMxPINod;
910     k = 2 * j;
911     Handle(HLRAlgo_HArray1OfPINod) NwPINod =
912       new HLRAlgo_HArray1OfPINod(0,k);
913     HLRAlgo_Array1OfPINod& oPINod = myPINod->ChangeArray1();
914     HLRAlgo_Array1OfPINod& nPINod = NwPINod->ChangeArray1();
915     Handle(HLRAlgo_PolyInternalNode)* ON = &(oPINod.ChangeValue(1));
916     Handle(HLRAlgo_PolyInternalNode)* NN = &(nPINod.ChangeValue(1));
917
918     for (i = 1; i <= j; i++) {
919       *NN = *ON;
920       ON++;
921       NN++;
922     }
923     myMxPINod = k;
924     myPINod = NwPINod;
925     if (PINod1 == PINod2) {
926       PINod1 = &nPINod;
927       PINod2 = PINod1;
928     }
929     else {
930       PINod1 = &nPINod;
931     }
932   }
933   myNbPINod++;
934 }