Commit | Line | Data |
---|---|---|
b311480e | 1 | // Created on: 1992-11-09 |
2 | // Created by: Didier PIFFAULT | |
3 | // Copyright (c) 1992-1999 Matra Datavision | |
973c2be1 | 4 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e | 5 | // |
973c2be1 | 6 | // This file is part of Open CASCADE Technology software library. |
b311480e | 7 | // |
d5f74e42 | 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 | |
973c2be1 | 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. | |
b311480e | 13 | // |
973c2be1 | 14 | // Alternatively, this file may be used under the terms of Open CASCADE |
15 | // commercial license or contractual agreement. | |
7fd59977 | 16 | |
47cbf134 | 17 | |
42cf5bc1 | 18 | #include <Bnd_BoundSortBox.hxx> |
19 | #include <Bnd_HArray1OfBox.hxx> | |
7fd59977 | 20 | #include <gp_Pnt.hxx> |
42cf5bc1 | 21 | #include <gp_Vec.hxx> |
22 | #include <gp_XYZ.hxx> | |
23 | #include <Intf.hxx> | |
7fd59977 | 24 | #include <Intf_SectionLine.hxx> |
42cf5bc1 | 25 | #include <Intf_SectionPoint.hxx> |
7fd59977 | 26 | #include <Intf_SeqOfSectionLine.hxx> |
42cf5bc1 | 27 | #include <Intf_SeqOfSectionPoint.hxx> |
7fd59977 | 28 | #include <Intf_SeqOfTangentZone.hxx> |
42cf5bc1 | 29 | #include <Intf_TangentZone.hxx> |
30 | #include <IntPatch_InterferencePolyhedron.hxx> | |
31 | #include <IntPatch_Polyhedron.hxx> | |
32 | #include <IntPatch_PolyhedronTool.hxx> | |
058f130e | 33 | #include <NCollection_LocalArray.hxx> |
42cf5bc1 | 34 | #include <TColStd_ListIteratorOfListOfInteger.hxx> |
35 | #include <TColStd_ListOfInteger.hxx> | |
058f130e | 36 | |
41194117 | 37 | static const int Pourcent3[9] = {0, 1, 2, 0, 1, 2, 0, 1, 2}; |
7fd59977 | 38 | |
39 | //======================================================================= | |
47cbf134 | 40 | //function : IntPatch_InterferencePolyhedron |
7fd59977 | 41 | //purpose : Empty constructor. |
42 | //======================================================================= | |
43 | ||
47cbf134 | 44 | IntPatch_InterferencePolyhedron::IntPatch_InterferencePolyhedron () |
d533dafb | 45 | : Intf_Interference(Standard_False), |
46 | Incidence(0) | |
47 | { | |
48 | memset (OI, 0, sizeof (OI)); | |
49 | memset (TI, 0, sizeof (TI)); | |
50 | memset (dpOeT, 0, sizeof (dpOeT)); | |
51 | memset (dpOpT, 0, sizeof (dpOpT)); | |
52 | memset (deOpT, 0, sizeof (deOpT)); | |
53 | } | |
7fd59977 | 54 | |
55 | //======================================================================= | |
47cbf134 | 56 | //function : IntPatch_InterferencePolyhedron |
7fd59977 | 57 | //purpose : |
58 | //======================================================================= | |
59 | ||
47cbf134 | 60 | IntPatch_InterferencePolyhedron::IntPatch_InterferencePolyhedron |
61 | (const IntPatch_Polyhedron& FirstPol, const IntPatch_Polyhedron& SeconPol) | |
d533dafb | 62 | : Intf_Interference(Standard_False), |
63 | Incidence(0) | |
7fd59977 | 64 | { |
d533dafb | 65 | memset (OI, 0, sizeof (OI)); |
66 | memset (TI, 0, sizeof (TI)); | |
67 | memset (dpOeT, 0, sizeof (dpOeT)); | |
68 | memset (dpOpT, 0, sizeof (dpOpT)); | |
69 | memset (deOpT, 0, sizeof (deOpT)); | |
47cbf134 | 70 | if (!IntPatch_PolyhedronTool::Bounding(FirstPol).IsOut |
71 | (IntPatch_PolyhedronTool::Bounding(SeconPol))) { | |
72 | Tolerance=IntPatch_PolyhedronTool::DeflectionOverEstimation(FirstPol)+ | |
73 | IntPatch_PolyhedronTool::DeflectionOverEstimation(SeconPol); | |
7fd59977 | 74 | if (Tolerance==0.) |
75 | Tolerance=Epsilon(1000.); | |
76 | Interference(FirstPol, SeconPol); | |
77 | } | |
78 | } | |
79 | ||
80 | //======================================================================= | |
47cbf134 | 81 | //function : IntPatch_InterferencePolyhedron |
7fd59977 | 82 | //purpose : |
83 | //======================================================================= | |
84 | ||
47cbf134 | 85 | IntPatch_InterferencePolyhedron::IntPatch_InterferencePolyhedron |
86 | (const IntPatch_Polyhedron& Objet) | |
d533dafb | 87 | : Intf_Interference(Standard_True), |
88 | Incidence(0) | |
7fd59977 | 89 | { |
d533dafb | 90 | memset (OI, 0, sizeof (OI)); |
91 | memset (TI, 0, sizeof (TI)); | |
92 | memset (dpOeT, 0, sizeof (dpOeT)); | |
93 | memset (dpOpT, 0, sizeof (dpOpT)); | |
94 | memset (deOpT, 0, sizeof (deOpT)); | |
47cbf134 | 95 | Tolerance=IntPatch_PolyhedronTool::DeflectionOverEstimation(Objet)*2; |
7fd59977 | 96 | if (Tolerance==0.) |
97 | Tolerance=Epsilon(1000.); | |
98 | Interference(Objet,Objet); //-- lbr le 5 juillet 96 | |
99 | } | |
100 | ||
101 | ||
102 | //======================================================================= | |
103 | //function : Perform | |
104 | //purpose : | |
105 | //======================================================================= | |
106 | ||
47cbf134 | 107 | void IntPatch_InterferencePolyhedron::Perform |
108 | (const IntPatch_Polyhedron& FirstPol, const IntPatch_Polyhedron& SeconPol) | |
7fd59977 | 109 | { |
110 | SelfInterference(Standard_False); | |
47cbf134 | 111 | if (!IntPatch_PolyhedronTool::Bounding(FirstPol).IsOut |
112 | (IntPatch_PolyhedronTool::Bounding(SeconPol))) { | |
113 | Tolerance=IntPatch_PolyhedronTool::DeflectionOverEstimation(FirstPol)+ | |
114 | IntPatch_PolyhedronTool::DeflectionOverEstimation(SeconPol); | |
7fd59977 | 115 | if (Tolerance==0.) |
116 | Tolerance=Epsilon(1000.); | |
117 | Interference(FirstPol, SeconPol); | |
118 | } | |
119 | } | |
120 | ||
121 | //======================================================================= | |
122 | //function : Perform | |
123 | //purpose : | |
124 | //======================================================================= | |
125 | ||
47cbf134 | 126 | void IntPatch_InterferencePolyhedron::Perform |
127 | (const IntPatch_Polyhedron& Objet) | |
7fd59977 | 128 | { |
129 | SelfInterference(Standard_True); | |
47cbf134 | 130 | Tolerance=IntPatch_PolyhedronTool::DeflectionOverEstimation(Objet)*2; |
7fd59977 | 131 | if (Tolerance==0.) |
132 | Tolerance=Epsilon(1000.); | |
133 | Interference(Objet); | |
134 | } | |
135 | ||
136 | ||
137 | //======================================================================= | |
138 | //function : Interference | |
139 | //purpose : | |
140 | //======================================================================= | |
141 | ||
47cbf134 | 142 | void IntPatch_InterferencePolyhedron::Interference |
143 | (const IntPatch_Polyhedron&) | |
7fd59977 | 144 | {} |
145 | ||
47cbf134 | 146 | void IntPatch_InterferencePolyhedron::Interference |
147 | (const IntPatch_Polyhedron& FirstPol, const IntPatch_Polyhedron& SeconPol) | |
7fd59977 | 148 | { |
149 | Standard_Boolean gridOnFirst=Standard_True; | |
47cbf134 | 150 | Standard_Integer NbTrianglesFirstPol = IntPatch_PolyhedronTool::NbTriangles(FirstPol); |
151 | Standard_Integer NbTrianglesSecondPol = IntPatch_PolyhedronTool::NbTriangles(SeconPol); | |
41194117 | 152 | Standard_Integer iFirst, iSecon; |
7fd59977 | 153 | |
154 | //------------------------------------------------------------------------------------------ | |
155 | //-- the same number of triangles it is necessary to test better on | |
156 | //-- the size of boxes. | |
157 | //-- | |
158 | //-- the second is chosen if nbTri1 > 2*nbTri2 or if VolBoit1 > 2*VolBoit2 | |
159 | //-- | |
160 | //--if (!SelfIntf && NbTrianglesFirstPol>NbTrianglesSecondPol) | |
161 | //-- gridOnFirst=Standard_False; | |
162 | ||
163 | if(!SelfIntf) { | |
164 | if(NbTrianglesFirstPol > NbTrianglesSecondPol+NbTrianglesSecondPol) gridOnFirst=Standard_False; | |
165 | ||
166 | Standard_Real vol1,vol2,Xmin, Ymin, Zmin, Xmax, Ymax, Zmax; | |
47cbf134 | 167 | IntPatch_PolyhedronTool::Bounding(FirstPol).Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax); |
7fd59977 | 168 | vol1 = (Xmax-Xmin)*(Ymax-Ymin)*(Zmax-Zmin); |
169 | ||
47cbf134 | 170 | IntPatch_PolyhedronTool::Bounding(SeconPol).Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax); |
7fd59977 | 171 | vol2 = (Xmax-Xmin)*(Ymax-Ymin)*(Zmax-Zmin); |
172 | ||
173 | if(vol1> 8.0*vol2) gridOnFirst=Standard_False; | |
174 | } | |
175 | ||
176 | ||
177 | if (gridOnFirst) { | |
178 | Bnd_BoundSortBox TheGridFirst; | |
47cbf134 | 179 | TheGridFirst.Initialize(IntPatch_PolyhedronTool::Bounding(FirstPol), |
180 | IntPatch_PolyhedronTool::ComponentsBounding(FirstPol)); | |
7fd59977 | 181 | |
182 | for (iSecon=1; iSecon<=NbTrianglesSecondPol; iSecon++) { | |
183 | ||
184 | TColStd_ListIteratorOfListOfInteger iLoI(TheGridFirst.Compare | |
47cbf134 | 185 | (IntPatch_PolyhedronTool::ComponentsBounding(SeconPol)->Value(iSecon))); |
7fd59977 | 186 | while (iLoI.More()) { |
187 | iFirst=iLoI.Value(); | |
188 | if (SelfIntf) { | |
189 | if (iFirst<iSecon) | |
190 | Intersect(iFirst, FirstPol, iSecon, SeconPol); | |
191 | } | |
192 | else | |
193 | Intersect(iFirst, FirstPol, iSecon, SeconPol); | |
194 | iLoI.Next(); | |
195 | } | |
196 | } | |
197 | } | |
198 | ||
199 | else { | |
200 | Bnd_BoundSortBox TheGridSecond; | |
47cbf134 | 201 | TheGridSecond.Initialize(IntPatch_PolyhedronTool::Bounding(SeconPol), |
202 | IntPatch_PolyhedronTool::ComponentsBounding(SeconPol)); | |
7fd59977 | 203 | |
204 | for (iFirst=1; iFirst<=NbTrianglesFirstPol; iFirst++) { | |
205 | TColStd_ListIteratorOfListOfInteger | |
206 | iLoI(TheGridSecond.Compare | |
47cbf134 | 207 | (IntPatch_PolyhedronTool::ComponentsBounding(FirstPol)->Value(iFirst))); |
7fd59977 | 208 | |
209 | while (iLoI.More()) { | |
210 | iSecon=iLoI.Value(); | |
211 | if (SelfIntf) { | |
212 | if (iFirst<iSecon) | |
213 | Intersect(iFirst, FirstPol, iSecon, SeconPol); | |
214 | } | |
215 | else | |
216 | Intersect(iFirst, FirstPol, iSecon, SeconPol); | |
217 | iLoI.Next(); | |
218 | } | |
219 | } | |
220 | } | |
221 | } | |
222 | ||
223 | ||
224 | //======================================================================= | |
225 | //function : Intersect | |
226 | //purpose : Intersection of two triangles issue from two Polyhedron. | |
227 | //======================================================================= | |
228 | ||
47cbf134 | 229 | void IntPatch_InterferencePolyhedron::Intersect |
230 | (const Standard_Integer Tri1, const IntPatch_Polyhedron& FirstPol, | |
231 | const Standard_Integer Tri2, const IntPatch_Polyhedron& SeconPol) | |
7fd59977 | 232 | { |
47cbf134 | 233 | IntPatch_PolyhedronTool::Triangle(FirstPol, Tri1,OI[0],OI[1],OI[2]); |
234 | IntPatch_PolyhedronTool::Triangle(SeconPol, Tri2,TI[0],TI[1],TI[2]); | |
7fd59977 | 235 | |
236 | // If there is an intersection of a polyhedron with itself, the | |
237 | // intersections are excluded | |
238 | // from a triangle with connected triangles : | |
239 | ||
240 | if (SelfIntf) { | |
241 | if (OI[0]==TI[0] || OI[0]==TI[1] || OI[0]==TI[2] || | |
242 | OI[1]==TI[0] || OI[1]==TI[1] || OI[1]==TI[2] || | |
243 | OI[2]==TI[0] || OI[2]==TI[1] || OI[2]==TI[2] ) return; | |
244 | } | |
245 | ||
246 | // The precision of intersections includes two values ; | |
247 | ||
248 | // - Tolerance :This value allows detecting potential | |
249 | // intersections in all cases. The value should be the | |
250 | // sum of upper bounds of tops pof two polyhedrons. | |
251 | ||
252 | // - floatGap : This value is the actual precision of calculation | |
253 | // of line of section.Its value is very small, it | |
254 | // allows having the same behaviour for | |
255 | // geometry tests as for the values used. | |
256 | ||
257 | Standard_Real floatGap=1e-13 ; //-- Epsilon(1000.); | |
258 | ||
259 | ||
260 | // Equation of the triangle plane of the objet | |
261 | gp_XYZ ONor; // Normal vector. | |
262 | Standard_Real Odp; // Polar Distance. | |
47cbf134 | 263 | Intf::PlaneEquation(IntPatch_PolyhedronTool::Point(FirstPol, OI[0]), |
264 | IntPatch_PolyhedronTool::Point(FirstPol, OI[1]), | |
265 | IntPatch_PolyhedronTool::Point(FirstPol, OI[2]), | |
7fd59977 | 266 | ONor, Odp); |
267 | ||
268 | ||
269 | // Equation of the triangle plane of the tool | |
270 | gp_XYZ TNor; // Normal vector. | |
271 | Standard_Real Tdp; // Polar distance. | |
47cbf134 | 272 | Intf::PlaneEquation(IntPatch_PolyhedronTool::Point(SeconPol, TI[0]), |
273 | IntPatch_PolyhedronTool::Point(SeconPol, TI[1]), | |
274 | IntPatch_PolyhedronTool::Point(SeconPol, TI[2]), | |
7fd59977 | 275 | TNor, Tdp); |
276 | ||
277 | ||
278 | // Scalar product of two normalized vectors -> cosinus of the angle | |
279 | Incidence= Abs(TNor*ONor); | |
280 | ||
281 | // Distance of the plane of the triangle from the object by three points of SeconPol | |
282 | Standard_Real dfOpT[3]; | |
47cbf134 | 283 | dfOpT[0]=ONor*(IntPatch_PolyhedronTool::Point(SeconPol, TI[0]).XYZ())-Odp; |
284 | dfOpT[1]=ONor*(IntPatch_PolyhedronTool::Point(SeconPol, TI[1]).XYZ())-Odp; | |
285 | dfOpT[2]=ONor*(IntPatch_PolyhedronTool::Point(SeconPol, TI[2]).XYZ())-Odp; | |
7fd59977 | 286 | |
287 | // Distance of the plane of the triangle from the tool by three points of FirstPol | |
288 | Standard_Real dpOfT[3]; | |
47cbf134 | 289 | dpOfT[0]=TNor*(IntPatch_PolyhedronTool::Point(FirstPol, OI[0]).XYZ())-Tdp; |
290 | dpOfT[1]=TNor*(IntPatch_PolyhedronTool::Point(FirstPol, OI[1]).XYZ())-Tdp; | |
291 | dpOfT[2]=TNor*(IntPatch_PolyhedronTool::Point(FirstPol, OI[2]).XYZ())-Tdp; | |
7fd59977 | 292 | |
293 | // Values defining the couple of triangle dpOpT, dpOeT, deOpT | |
294 | CoupleCharacteristics(FirstPol, SeconPol); | |
295 | ||
296 | // If three points of the triangle of <SeconPol> are in the plane of the | |
297 | // triangle of <Obje> within <Tolerance> the eventual tangency zone is found. | |
298 | ||
299 | Intf_TangentZone TheTZ; | |
300 | if ((Abs(dfOpT[0])<=Tolerance && | |
301 | Abs(dfOpT[1])<=Tolerance && | |
302 | Abs(dfOpT[2])<=Tolerance) && | |
303 | (Abs(dpOfT[0])<=Tolerance && | |
304 | Abs(dpOfT[1])<=Tolerance && | |
305 | Abs(dpOfT[2])<=Tolerance) && | |
306 | (Abs(dfOpT[0]+dfOpT[1]+dfOpT[2])!= | |
307 | Abs(dfOpT[0])+Abs(dfOpT[1])+Abs(dfOpT[2])) && | |
308 | (Abs(dpOfT[0]+dpOfT[1]+dpOfT[2])!= | |
309 | Abs(dpOfT[0])+Abs(dpOfT[1])+Abs(dpOfT[2]))){ | |
310 | ||
41194117 K |
311 | if (TangentZoneValue(TheTZ, FirstPol, Tri1, SeconPol, Tri2)) |
312 | { | |
7fd59977 | 313 | if (!Insert(TheTZ)) myTZones.Append(TheTZ); |
314 | } | |
315 | } | |
316 | ||
317 | // Otherwise line of section is calculated: | |
318 | else { | |
319 | Standard_Integer iObj, iToo; | |
320 | ||
321 | // Zone de stockage des resultats : | |
322 | Standard_Integer nbpiOT=0; | |
323 | Standard_Integer nbpiO=0; | |
324 | Standard_Integer nbpiT=0; | |
325 | Intf_SeqOfSectionPoint piOT; | |
326 | Standard_Real parO[3]; | |
327 | Standard_Real parT[3]; | |
328 | ||
329 | // Indicateurs d arete touchee | |
330 | Standard_Integer edOT[3]; | |
331 | Standard_Integer edTT[3]; | |
332 | ||
333 | // Initializations | |
334 | //--for (iObj=0; iObj<3; iObj++) { | |
335 | // parO[iObj]=parT[iObj]=-1.; | |
336 | // edOT[iObj]=edTT[iObj]=1; | |
337 | //--} | |
338 | parO[0]=parT[0]=parO[1]=parT[1]=parO[2]=parT[2]=-1.0; | |
339 | edOT[0]=edTT[0]=edOT[1]=edTT[1]=edOT[2]=edTT[2]= 1; | |
340 | ||
341 | // Singularite VERTEX VERTEX | |
342 | //for (iObj=0; iObj<3; iObj++) { | |
343 | // for (iToo=0; iToo<3; iToo++) { | |
344 | // if (dpOpT[iObj][iToo] <= floatGap) { | |
47cbf134 | 345 | // piOT.Append(Intf_SectionPoint(IntPatch_PolyhedronTool::Point(FirstPol, OI[iObj]), |
7fd59977 | 346 | // Intf_VERTEX, OI[iObj], 0, 0., |
347 | // Intf_VERTEX, TI[iToo], 0, 0., | |
348 | // Incidence)); | |
349 | // parO[iObj]=0.; | |
350 | // parT[iToo]=0.; | |
351 | // edOT[Pourcent3[iObj+2]]=0; edOT[iObj]=0; | |
352 | // edTT[Pourcent3[iToo+2]]=0; edTT[iToo]=0; | |
353 | // nbpiOT++; nbpiO++; nbpiT++; | |
354 | // } | |
355 | // } | |
356 | //} | |
357 | //----------------------------> | |
358 | for (iObj=0; iObj<3; iObj++) { | |
359 | for (iToo=0; iToo<3; iToo++) { | |
360 | if (dpOpT[iObj][iToo] <= floatGap) { | |
47cbf134 | 361 | piOT.Append(Intf_SectionPoint(IntPatch_PolyhedronTool::Point(FirstPol, OI[iObj]), |
7fd59977 | 362 | Intf_VERTEX, OI[iObj], 0, 0., |
363 | Intf_VERTEX, TI[iToo], 0, 0., | |
364 | Incidence)); | |
365 | parO[iObj]=parT[iToo]=0.0; | |
366 | edOT[Pourcent3[iObj+2]]=edOT[iObj]=edTT[Pourcent3[iToo+2]]=edTT[iToo]=0; | |
367 | nbpiOT++; nbpiO++; nbpiT++; | |
368 | } | |
369 | } | |
370 | } | |
371 | ||
372 | ||
373 | // Singularite VERTEX EDGE | |
374 | Standard_Integer inext, jnext; | |
375 | for (iObj=0; iObj<3; iObj++) { | |
376 | if (parO[iObj]==-1.) { | |
377 | for (iToo=0; iToo<3; iToo++) { | |
378 | inext=Pourcent3[iToo+1]; | |
379 | if (edTT[iToo]==1) { | |
380 | if (dpOeT[iObj][iToo] <= floatGap && dpOeT[iObj][iToo]>=-floatGap ) { | |
381 | if ((dpOpT[iObj][iToo]+dpOpT[iObj][inext])<vtt[iToo].Modulus()) { | |
382 | parT[iToo]=dpOpT[iObj][iToo]/(dpOpT[iObj][iToo]+ | |
383 | dpOpT[iObj][inext]); | |
384 | if (TI[iToo]>TI[inext]) parT[iToo]=1.-parT[iToo]; | |
385 | piOT.Append(Intf_SectionPoint | |
47cbf134 | 386 | (IntPatch_PolyhedronTool::Point(FirstPol, OI[iObj]), |
7fd59977 | 387 | Intf_VERTEX, OI[iObj], 0, 0., |
388 | Intf_EDGE, Min(TI[iToo],TI[inext]), | |
389 | Max(TI[iToo],TI[inext]), parT[iToo], | |
390 | Incidence)); | |
391 | parO[iObj]=0.; | |
392 | edOT[Pourcent3[iObj+2]]=0; edOT[iObj]=0; | |
393 | edTT[iToo]=0; | |
394 | nbpiOT++; nbpiO++; nbpiT++; | |
395 | } | |
396 | } | |
397 | } | |
398 | } | |
399 | } | |
400 | } | |
401 | ||
402 | // Singularite EDGE VERTEX | |
403 | for (iToo=0; iToo<3; iToo++) { | |
404 | if (parT[iToo]==-1.) { | |
405 | for (iObj=0; iObj<3; iObj++) { | |
406 | inext=Pourcent3[iObj+1]; | |
407 | if (edOT[iObj]==1) { | |
408 | if (Abs(deOpT[iObj][iToo]) <= floatGap) { | |
409 | if ((dpOpT[iObj][iToo]+dpOpT[inext][iToo])<voo[iObj].Modulus()){ | |
410 | parO[iObj]=dpOpT[iObj][iToo]/(dpOpT[iObj][iToo]+ | |
411 | dpOpT[inext][iToo]); | |
412 | if (OI[iObj]>OI[inext]) parO[iObj]=1.-parO[iObj]; | |
413 | piOT.Append(Intf_SectionPoint | |
47cbf134 | 414 | (IntPatch_PolyhedronTool::Point(SeconPol, TI[iToo]), |
7fd59977 | 415 | Intf_EDGE, Min(OI[iObj],OI[inext]), |
416 | Max(OI[iObj],OI[inext]), parO[iObj], | |
417 | Intf_VERTEX, TI[iToo], 0, 0., | |
418 | Incidence)); | |
419 | parT[iToo]=0.; | |
420 | edOT[iObj]=edTT[Pourcent3[iToo+2]]=edTT[iToo]=0; | |
421 | nbpiOT++; nbpiO++; nbpiT++; | |
422 | } | |
423 | } | |
424 | } | |
425 | } | |
426 | } | |
427 | } | |
428 | ||
429 | // Singularite FACE VERTEX | |
430 | for (iToo=0; iToo<3; iToo++) { | |
431 | if (parT[iToo]!=0.) { | |
432 | if (Abs(dfOpT[iToo]) <= floatGap) { | |
47cbf134 | 433 | piOT.Append(Intf_SectionPoint(IntPatch_PolyhedronTool::Point(SeconPol, TI[iToo]), |
7fd59977 | 434 | Intf_FACE, Tri1, 0, 0., |
435 | Intf_VERTEX, TI[iToo], 0, 0., | |
436 | Incidence)); | |
437 | parT[iToo]=0.; | |
438 | edTT[Pourcent3[iToo+2]]=edTT[iToo]=0; | |
439 | nbpiOT++; nbpiT++; | |
440 | } | |
441 | } | |
442 | } | |
443 | ||
444 | // Singularite VERTEX FACE | |
445 | for (iObj=0; iObj<3; iObj++) { | |
446 | if (parO[iObj]!=0.) { | |
447 | if (Abs(dpOfT[iObj]) <= floatGap) { | |
47cbf134 | 448 | piOT.Append(Intf_SectionPoint(IntPatch_PolyhedronTool::Point(FirstPol, OI[iObj]), |
7fd59977 | 449 | Intf_VERTEX, OI[iObj], 0, 0., |
450 | Intf_FACE, Tri2, 0, 0., | |
451 | Incidence)); | |
452 | parO[iObj]=0.; | |
453 | edOT[Pourcent3[iObj+2]]=edOT[iObj]=0; | |
454 | nbpiOT++; nbpiO++; | |
455 | } | |
456 | } | |
457 | } | |
458 | ||
459 | // Singularite EDGE EDGE | |
460 | gp_Pnt piO; | |
461 | gp_XYZ piT; | |
462 | Standard_Real lg; | |
463 | for (iObj=0; iObj<3; iObj++) { | |
464 | inext=Pourcent3[iObj+1]; | |
465 | if (edOT[iObj]==1 && (dpOfT[iObj]*dpOfT[inext])<0.) { | |
466 | lg=dpOfT[iObj]/(dpOfT[iObj]-dpOfT[inext]); | |
467 | if (lg>0. && lg<1.) { | |
468 | for (iToo=0; iToo<3; iToo++) { | |
469 | jnext=Pourcent3[iToo+1]; | |
470 | if (edTT[iToo]==1 && (dfOpT[iToo]*dfOpT[jnext])<0.) { | |
471 | lg=dfOpT[iToo]/(dfOpT[iToo]-dfOpT[jnext]); | |
472 | if (lg>0. && lg<1.) { | |
473 | Standard_Boolean Pb=Standard_False; | |
474 | if (OI[iObj]>OI[inext]) { | |
475 | Standard_Real div=(dpOeT[inext][iToo]-dpOeT[iObj][iToo]); | |
476 | if(div>floatGap || div<-floatGap) { | |
477 | parO[iObj]=dpOeT[inext][iToo]/div; | |
47cbf134 | 478 | piO=(IntPatch_PolyhedronTool::Point(FirstPol,OI[inext]).XYZ()) + |
7fd59977 | 479 | (voo[iObj].Reversed()*parO[iObj]); |
480 | } | |
481 | else | |
482 | Pb=Standard_True; | |
483 | } | |
484 | else { | |
485 | Standard_Real div = dpOeT[iObj][iToo]-dpOeT[inext][iToo]; | |
486 | if(div>floatGap || div<-floatGap) { | |
487 | parO[iObj]=dpOeT[iObj][iToo]/ | |
8c2d3314 | 488 | (dpOeT[iObj][iToo]-dpOeT[inext][iToo]); |
47cbf134 | 489 | piO=(IntPatch_PolyhedronTool::Point(FirstPol,OI[iObj]).XYZ()) + |
7fd59977 | 490 | (voo[iObj]*parO[iObj]); |
491 | } | |
492 | else | |
493 | Pb=Standard_True; | |
494 | } | |
495 | if (TI[iToo]>TI[jnext]) { | |
496 | Standard_Real div=(deOpT[iObj][jnext]-deOpT[iObj][iToo]); | |
497 | if(div>floatGap || div<-floatGap) { | |
498 | parT[iToo]=deOpT[iObj][jnext]/div; | |
47cbf134 | 499 | piT=(IntPatch_PolyhedronTool::Point(SeconPol,TI[jnext]).XYZ()) + |
7fd59977 | 500 | (vtt[iToo].Reversed()*parT[iToo]); |
501 | } | |
502 | else | |
503 | Pb=Standard_True; | |
504 | } | |
505 | else { | |
506 | Standard_Real div=(deOpT[iObj][iToo]-deOpT[iObj][jnext]); | |
507 | if(div>floatGap || div<-floatGap) { | |
508 | parT[iToo]=deOpT[iObj][iToo]/div; | |
47cbf134 | 509 | piT=(IntPatch_PolyhedronTool::Point(SeconPol,TI[iToo]).XYZ()) + |
7fd59977 | 510 | (vtt[iToo]*parT[iToo]); |
511 | } | |
512 | else | |
513 | Pb=Standard_True; | |
514 | } | |
515 | if(Pb==Standard_False) { | |
516 | piT-=piO.XYZ(); | |
517 | lg=piT.Modulus(); | |
518 | if (lg <= floatGap){ | |
519 | piOT.Append(Intf_SectionPoint | |
520 | (piO, | |
521 | Intf_EDGE, Min(OI[iObj],OI[inext]), | |
522 | Max(OI[iObj],OI[inext]), parO[iObj], | |
523 | Intf_EDGE, Min(TI[iToo],TI[jnext]), | |
524 | Max(TI[iToo],TI[jnext]), parT[iToo], | |
525 | Incidence)); | |
526 | edOT[iObj]=edTT[iToo]=0; | |
527 | nbpiOT++; nbpiO++; nbpiT++; | |
528 | } | |
529 | } | |
530 | } | |
531 | } | |
532 | } | |
533 | } | |
534 | } | |
535 | } | |
536 | ||
537 | // Intersection EDGE FACE | |
538 | for (iObj=0; iObj<3; iObj++) { | |
539 | inext=Pourcent3[iObj+1]; | |
540 | if (edOT[iObj]==1 && (dpOfT[iObj]*dpOfT[inext])<0.) { | |
541 | lg=dpOfT[iObj]/(dpOfT[iObj]-dpOfT[inext]); | |
542 | if (lg>0. && lg<1.) { | |
543 | parO[iObj]=lg; | |
47cbf134 | 544 | piO=(IntPatch_PolyhedronTool::Point(FirstPol, OI[iObj]).XYZ())+ |
7fd59977 | 545 | (voo[iObj]*parO[iObj]); |
546 | if (OI[iObj]>OI[inext]) parO[iObj]=1.-parO[iObj]; | |
547 | piOT.Append( | |
548 | Intf_SectionPoint (piO, | |
549 | Intf_EDGE, Min(OI[iObj],OI[inext]), | |
550 | Max(OI[iObj],OI[inext]), parO[iObj], | |
551 | Intf_FACE, Tri2, 0, 0., Incidence)); | |
552 | nbpiOT++; nbpiO++; | |
553 | } | |
554 | } | |
555 | } | |
556 | ||
557 | // Intersection FACE EDGE | |
558 | for (iToo=0; iToo<3; iToo++) { | |
559 | jnext=Pourcent3[iToo+1]; | |
560 | if (edTT[iToo]==1 && (dfOpT[iToo]*dfOpT[jnext])<0.) { | |
561 | lg=dfOpT[iToo]/(dfOpT[iToo]-dfOpT[jnext]); | |
562 | if (lg>0. && lg<1.) { | |
563 | parT[iToo]=lg; | |
47cbf134 | 564 | piO=(IntPatch_PolyhedronTool::Point(SeconPol, TI[iToo]).XYZ())+ |
7fd59977 | 565 | (vtt[iToo]*parT[iToo]); |
566 | if (TI[iToo]>TI[jnext]) parT[iToo]=1.-parT[iToo]; | |
567 | piOT.Append(Intf_SectionPoint | |
568 | (piO, | |
569 | Intf_FACE, Tri1, 0, 0., | |
570 | Intf_EDGE, Min(TI[iToo],TI[jnext]), | |
571 | Max(TI[iToo],TI[jnext]), parT[iToo], | |
572 | Incidence)); | |
573 | nbpiOT++; nbpiT++; | |
574 | } | |
575 | } | |
576 | } | |
577 | ||
058f130e | 578 | NCollection_LocalArray <Standard_Integer> id(Max(nbpiOT, 4)); |
7fd59977 | 579 | |
7fd59977 | 580 | Standard_Integer ideb=-1; |
581 | Standard_Integer ifin=-2; | |
582 | ||
583 | if (nbpiOT>1) { | |
584 | ||
585 | // Sort the <nbpiOT> sections points along the intersection beetween the | |
586 | // two triangles : | |
587 | ||
588 | gp_XYZ dir=ONor^TNor; | |
058f130e | 589 | NCollection_LocalArray <Standard_Real> d(nbpiOT); |
7fd59977 | 590 | Standard_Integer iPi, iPs; |
591 | for (iPi=0; iPi<nbpiOT; iPi++) { | |
592 | d[iPi]=dir*piOT(iPi+1).Pnt().XYZ(); | |
593 | } | |
594 | ||
595 | Standard_Integer di; | |
596 | id[0]=0; | |
597 | for (iPi=1; iPi<nbpiOT; iPi++) { | |
598 | id[iPi]=iPi; | |
599 | for (iPs=iPi-1; iPs>=0; iPs--) { | |
600 | if (d[id[iPs]] > d[id[iPs+1]]) { | |
601 | di=id[iPs+1]; | |
602 | id[iPs+1]=id[iPs]; | |
603 | id[iPs]=di; | |
604 | } | |
605 | else break; | |
606 | } | |
607 | } | |
608 | } | |
609 | ||
610 | // Possibility of line of section : | |
611 | ||
612 | if (nbpiO==2 && nbpiT==2) { | |
613 | ||
614 | // In the case when an edge is in the plane of the other triangle | |
615 | // it is necessary to check if it has not been already processed | |
616 | // on a connected triangle : | |
617 | ||
618 | // Pour l objet : | |
619 | Standard_Integer pivo=-1; | |
620 | Standard_Integer pedg=-1; | |
621 | if (parO[0]==0.) { | |
622 | pivo=0; | |
623 | if (parO[1]==0.) pedg=1; | |
624 | else if (parO[2]==0.) pedg=2; | |
625 | } | |
626 | else if (parO[1]==0.) { | |
627 | pivo=1; | |
628 | if (parO[2]==0.) pedg=2; | |
629 | } | |
630 | if (pivo>=0 && pedg>=0) { | |
47cbf134 | 631 | IntPatch_PolyhedronTool::TriConnex(FirstPol, Tri1,OI[pivo],OI[pedg],pivo,pedg); |
7fd59977 | 632 | if (pivo > Tri1) { |
633 | nbpiOT=0; | |
634 | ideb=-1; // On a deja trouve celle ci | |
635 | ifin=-2; | |
636 | } | |
637 | } | |
638 | ||
639 | // For the tool : | |
640 | pivo=-1; | |
641 | pedg=-1; | |
642 | if (parT[0]==0.) { | |
643 | pivo=0; | |
644 | if (parT[1]==0.) pedg=1; | |
645 | else if (parT[2]==0.) pedg=2; | |
646 | } | |
647 | else if (parT[1]==0.) { | |
648 | pivo=1; | |
649 | if (parT[2]==0.) pedg=2; | |
650 | } | |
651 | if (pivo>=0 && pedg>=0) { | |
47cbf134 | 652 | IntPatch_PolyhedronTool::TriConnex(SeconPol, Tri2,TI[pivo],TI[pedg],pivo,pedg); |
7fd59977 | 653 | if (pivo > Tri2) { |
654 | nbpiOT=0; | |
655 | ideb=-1; // It has been already found | |
656 | ifin=-2; | |
657 | } | |
658 | } | |
659 | ||
660 | if (nbpiOT>0) { | |
661 | ||
662 | // If there is a covering up : insert the section line in the existent | |
663 | // list or create a new section line : | |
664 | ||
665 | if (piOT(id[0]+1).TypeOnFirst()==Intf_FACE) { | |
666 | if (piOT(id[1]+1).TypeOnFirst()==Intf_FACE) { | |
667 | ideb=-id[0]-1; // No line of section possible | |
668 | ifin=-id[1]-1; // | |
669 | } | |
670 | else if (piOT(id[1]+1).TypeOnSecond()!=Intf_FACE) { | |
671 | ideb=id[1]; // No line of section possible | |
672 | ifin=id[1]; // only a pointersec | |
673 | } | |
674 | else if (nbpiOT>=3) { | |
675 | ideb=id[1]; // Retrieve 2 segments of section | |
676 | ifin=id[2]; // | |
677 | } | |
678 | else { | |
7fd59977 | 679 | ideb=-999; // No line of section possible |
680 | ifin=-999; | |
681 | } | |
682 | } | |
683 | else if (piOT(id[0]+1).TypeOnSecond()==Intf_FACE) { | |
684 | if (piOT(id[1]+1).TypeOnSecond()==Intf_FACE) { | |
685 | ideb=-id[0]-1; // No line of section possible | |
686 | ifin=-id[1]-1; // | |
687 | } | |
688 | else if (piOT(id[1]+1).TypeOnFirst()!=Intf_FACE) { | |
689 | ideb=id[1]; // No line of section possible | |
690 | ifin=id[1]; // only a pointersec | |
691 | } | |
692 | else if (nbpiOT>=3) { | |
693 | ideb=id[1]; // Recouvrement des 2 segments de section | |
694 | ifin=id[2]; // | |
695 | } | |
696 | else { | |
7fd59977 | 697 | ideb=-999; // No line of section possible |
698 | ifin=-999; | |
699 | } | |
700 | } | |
701 | ||
702 | else { // Singularity on the first point there is only two or | |
703 | ideb=id[0]; // three pointersec, so the first is a solution | |
704 | ifin=id[1]; // and the second too. | |
705 | } | |
706 | } | |
707 | ||
708 | ||
709 | // Insertion of the segment found in the existing section lines : | |
710 | ||
711 | if(ideb<0) { | |
712 | if(ifin<0) { | |
713 | if(ideb!=-999) { | |
714 | //static unsigned nisp=0; | |
715 | Standard_Real d=piOT(-ideb).Pnt().Distance(piOT(-ifin).Pnt()); | |
716 | if(d<Tolerance) { | |
717 | Insert(piOT(-ideb), piOT(-ifin)); | |
04232180 | 718 | //-- std::cout<<"Insertion Point IntPatch_InterferencePolyhedron 1,2 d="<<d<<" Tol="<<Tolerance<<" num:"<<++nisp<<std::endl; |
7fd59977 | 719 | //-- piOT(-ideb).Dump(1); piOT(-ifin).Dump(0); |
04232180 | 720 | //-- std::cout<<"point p"<<++nisp<<" "<<piOT(-ideb).Pnt().X()<<" "<<piOT(-ideb).Pnt().Y()<<" "<<piOT(-ideb).Pnt().Z()<<std::endl; |
7fd59977 | 721 | } |
722 | else { | |
04232180 | 723 | //-- std::cout<<"Insertion Point IntPatch_InterferencePolyhedron 1,2 d="<<d<<" Tol="<<Tolerance<<" NON INSERE "<<std::endl; |
7fd59977 | 724 | } |
725 | } | |
726 | } | |
727 | } | |
728 | else if (ideb>=0) { | |
729 | if (ideb!=ifin) { | |
730 | Insert(piOT(ideb+1), piOT(ifin+1)); | |
731 | ||
732 | // else | |
733 | // un pointersec : It is necessary to check if it has not been already found | |
734 | // and if not insert it in the list. | |
735 | // Attention! It is necessary to check | |
736 | // for each new segment if a point is in the list | |
737 | // and in this case remove it from the list. | |
738 | } | |
739 | } | |
740 | } | |
741 | } | |
742 | } | |
743 | ||
744 | ||
745 | //======================================================================= | |
746 | //function : TangentZoneValue | |
747 | //purpose : | |
748 | //======================================================================= | |
749 | ||
47cbf134 | 750 | Standard_Boolean IntPatch_InterferencePolyhedron::TangentZoneValue |
7fd59977 | 751 | (Intf_TangentZone& TheTZ, |
47cbf134 | 752 | const IntPatch_Polyhedron& FirstPol, |
7fd59977 | 753 | const Standard_Integer Tri1, |
47cbf134 | 754 | const IntPatch_Polyhedron& SeconPol, |
7fd59977 | 755 | const Standard_Integer Tri2) const |
756 | { | |
757 | // Potential tangent Zone ! | |
758 | // ------------------------ | |
759 | ||
760 | Standard_Boolean finished=Standard_False; | |
761 | Standard_Integer nob, nou, nob2, nou2; | |
762 | Standard_Real par; | |
763 | ||
764 | Intf_PIType tOP[3]; | |
765 | Intf_PIType tTP[3]; | |
766 | for (nou=0; nou<3; nou++) { | |
767 | tOP[nou]= Intf_EXTERNAL; | |
768 | tTP[nou]= Intf_EXTERNAL; | |
769 | } | |
7fd59977 | 770 | |
771 | Standard_Integer nbpInt=0; | |
772 | Intf_SeqOfSectionPoint Tpi; | |
773 | ||
774 | // Compute the positions of the points of <Tri1> in the triangle <Tri2>. | |
775 | for (nob=0; nob<=2; nob++) { | |
776 | nob2=Pourcent3[nob+1]; | |
777 | for (nou=0; nou<=2; nou++) { | |
778 | nou2=Pourcent3[nou+1]; | |
779 | if (dpOpT[nob][nou]<=Tolerance) { | |
47cbf134 | 780 | Tpi.Append(Intf_SectionPoint(IntPatch_PolyhedronTool::Point(FirstPol, OI[nob]), |
7fd59977 | 781 | Intf_VERTEX, OI[nob], 0, 0., |
782 | Intf_VERTEX, TI[nou], 0, 0., | |
783 | 1.)); | |
96a95605 DB |
784 | tOP[nob]=Intf_VERTEX; |
785 | tTP[nou]=Intf_VERTEX; | |
7fd59977 | 786 | nbpInt++; |
787 | break; | |
788 | } | |
789 | else if (Abs(dpOeT[nob][nou])<=Tolerance) { | |
790 | if (dpOpT[nob][nou]+dpOpT[nob][nou2]<vtt[nou].Modulus()) { | |
791 | par=dpOpT[nob][nou]/(dpOpT[nob][nou]+dpOpT[nob][nou2]); | |
792 | if (TI[nou]>TI[nou2]) par=1.-par; | |
47cbf134 | 793 | Tpi.Append(Intf_SectionPoint (IntPatch_PolyhedronTool::Point(FirstPol, OI[nob]), |
7fd59977 | 794 | Intf_VERTEX, OI[nob], 0, 0., |
795 | Intf_EDGE, Min(TI[nou], TI[nou2]), | |
796 | Max(TI[nou], TI[nou2]), par, | |
797 | 1.)); | |
96a95605 | 798 | tOP[nob]=Intf_EDGE; |
7fd59977 | 799 | nbpInt++; |
800 | break; | |
801 | } | |
802 | } | |
803 | } | |
804 | if (tOP[nob]==Intf_EXTERNAL) { | |
47cbf134 | 805 | if (Intf::Contain(IntPatch_PolyhedronTool::Point(SeconPol, TI[0]), |
806 | IntPatch_PolyhedronTool::Point(SeconPol, TI[1]), | |
807 | IntPatch_PolyhedronTool::Point(SeconPol, TI[2]), | |
808 | IntPatch_PolyhedronTool::Point(FirstPol, OI[nob]))) { | |
809 | Tpi.Append(Intf_SectionPoint(IntPatch_PolyhedronTool::Point(FirstPol, OI[nob]), | |
7fd59977 | 810 | Intf_VERTEX, OI[nob], 0, 0., |
811 | Intf_FACE, Tri2, 0, 0., | |
812 | 1.)); | |
96a95605 | 813 | tOP[nob]=Intf_FACE; |
7fd59977 | 814 | nbpInt++; |
815 | } | |
816 | } | |
817 | } | |
818 | ||
819 | // If the three points of <Tri1> are in <Tri2> the triangle Tri1 is | |
820 | // itself the tangent zone else compute the positions of the points | |
821 | // of <Tri2> in <Tri1>. | |
822 | if (nbpInt < 3) { | |
823 | for (nou=0; nou<=2; nou++) { | |
824 | nou2=Pourcent3[nou+1]; | |
825 | if (tTP[nou]==Intf_EXTERNAL) { | |
826 | for (nob=0; nob<=2; nob++) { | |
827 | nob2=Pourcent3[nob+1]; | |
828 | if (Abs(deOpT[nob][nou])<=Tolerance) { | |
829 | if (dpOpT[nob][nou]+dpOpT[nob2][nou]<voo[nob].Modulus()) { | |
830 | par=dpOpT[nob][nou]/(dpOpT[nob][nou]+dpOpT[nob2][nou]); | |
831 | if (OI[nob]>OI[nob2]) par=1.-par; | |
47cbf134 | 832 | Tpi.Append(Intf_SectionPoint(IntPatch_PolyhedronTool::Point(SeconPol,TI[nou]), |
7fd59977 | 833 | Intf_EDGE, Min(OI[nob], OI[nob2]), |
834 | Max(OI[nob], OI[nob2]), par, | |
835 | Intf_VERTEX, TI[nou], 0, 0., 1.)); | |
96a95605 | 836 | tTP[nou]=Intf_EDGE; |
7fd59977 | 837 | nbpInt++; |
838 | break; | |
839 | } | |
840 | } | |
841 | } | |
842 | if (tTP[nou]==Intf_EXTERNAL) { | |
47cbf134 | 843 | if (Intf::Contain(IntPatch_PolyhedronTool::Point(FirstPol, OI[0]), |
844 | IntPatch_PolyhedronTool::Point(FirstPol, OI[1]), | |
845 | IntPatch_PolyhedronTool::Point(FirstPol, OI[2]), | |
846 | IntPatch_PolyhedronTool::Point(SeconPol, TI[nou]))) { | |
847 | Tpi.Append(Intf_SectionPoint(IntPatch_PolyhedronTool::Point(SeconPol, TI[nou]), | |
7fd59977 | 848 | Intf_FACE, Tri1, 0, 0., |
849 | Intf_VERTEX, TI[nou], 0, 0., | |
850 | 1.)); | |
96a95605 | 851 | tTP[nou]=Intf_FACE; |
7fd59977 | 852 | nbpInt++; |
853 | } | |
854 | } | |
855 | } | |
856 | } | |
857 | if (tTP[0]!=Intf_EXTERNAL && | |
858 | tTP[1]!=Intf_EXTERNAL && | |
859 | tTP[2]!=Intf_EXTERNAL) | |
860 | finished=Standard_True; | |
861 | } | |
862 | else | |
863 | finished=Standard_True; | |
864 | ||
865 | // Insertion of the points of intersection in the zone of tangency : | |
866 | for (nob=1; nob<=nbpInt; nob++) | |
867 | TheTZ.Append(Tpi(nob)); | |
868 | ||
869 | if (!finished) { | |
870 | // If one of the triangles is not in the zone of tangency, it is necessary to find | |
871 | // the points of intersection edge/edge : | |
872 | ||
93dc7934 | 873 | // Last indexes are not used. |
874 | // Arrays are increased to eliminate gcc warning. | |
875 | Standard_Real parO[10], parT[10]; | |
7fd59977 | 876 | Standard_Integer nbNoInserted=0; |
9dc6c9b8 | 877 | Standard_Integer piToInsert[17]; // for GCC 4.9 |
7fd59977 | 878 | |
879 | for (nob=0; nob<3; nob++) { | |
880 | //processing of the object segment P[nob], P[nob+1] | |
881 | nob2=Pourcent3[nob+1]; | |
882 | ||
883 | for (nou=0; nou<3; nou++) { | |
884 | //processing of the segment of the tool P[nou], P[nou+1] | |
885 | nou2=Pourcent3[nou+1]; | |
886 | ||
887 | if (dpOeT[nob][nou]*dpOeT[nob2][nou]<0. && | |
888 | deOpT[nob][nou]*deOpT[nob][nou2]<0.) { | |
889 | ||
93dc7934 | 890 | if (nbpInt>=5) { |
7fd59977 | 891 | break; |
892 | } | |
893 | else { | |
894 | parO[nbpInt]=dpOeT[nob][nou]/(dpOeT[nob][nou]-dpOeT[nob2][nou]); | |
895 | parT[nbpInt]=deOpT[nob][nou]/(deOpT[nob][nou]-deOpT[nob][nou2]); | |
47cbf134 | 896 | gp_Pnt lepi=IntPatch_PolyhedronTool::Point(SeconPol, TI[nou]).Translated |
7fd59977 | 897 | (gp_Vec(vtt[nou]*parT[nbpInt])); |
898 | if (OI[nob]>OI[nob2]) parO[nbpInt]=1.-parO[nbpInt]; | |
899 | if (TI[nou]>TI[nou2]) parT[nbpInt]=1.-parT[nbpInt]; | |
900 | Tpi.Append(Intf_SectionPoint(lepi, | |
901 | Intf_EDGE, Min(OI[nob],OI[nob2]), | |
902 | Max(OI[nob],OI[nob2]), parO[nbpInt], | |
903 | Intf_EDGE, Min(TI[nou],TI[nou2]), | |
904 | Max(TI[nou],TI[nou2]), parT[nbpInt], | |
905 | Incidence)); | |
906 | nbpInt++; | |
907 | if (!TheTZ.Insert(Tpi(nbpInt))) { | |
908 | piToInsert[nbNoInserted]=nbpInt; | |
909 | nbNoInserted++; | |
910 | } | |
911 | } | |
912 | } | |
913 | } | |
93dc7934 | 914 | if (nbpInt>=5) break; // Number of pi passed in TZ ! |
7fd59977 | 915 | } |
916 | nob=nbNoInserted-1; | |
917 | while (nob>=0) { | |
918 | while (!TheTZ.Insert(Tpi(piToInsert[nob]))) { | |
919 | nob--; | |
920 | if (nob<0) break; | |
921 | } | |
922 | if (nob>=0) { | |
a820bd4f | 923 | nbNoInserted--; |
924 | while (nob < nbNoInserted) { | |
7fd59977 | 925 | piToInsert[nob]=piToInsert[nob+1]; |
926 | nob++; | |
927 | } | |
7fd59977 | 928 | nob=nbNoInserted-1; |
929 | } | |
930 | } | |
931 | if (nbNoInserted>0) { | |
7fd59977 | 932 | nob=nbNoInserted-1; |
933 | while (nob>=0) { | |
934 | Tpi(piToInsert[nob--]).Dump(4); | |
935 | } | |
936 | } | |
937 | } | |
938 | if (nbpInt<3) nbpInt=0; | |
939 | return nbpInt>0; | |
940 | } | |
941 | ||
942 | ||
943 | //======================================================================= | |
944 | //function : CoupleCharacteristics | |
945 | //purpose : | |
946 | //======================================================================= | |
947 | ||
47cbf134 | 948 | void IntPatch_InterferencePolyhedron::CoupleCharacteristics (const IntPatch_Polyhedron& FirstPol, |
949 | const IntPatch_Polyhedron& SeconPol) | |
7fd59977 | 950 | { |
951 | Standard_Integer n1, n2; | |
952 | Standard_Real lg; | |
953 | ||
954 | for (n1=0; n1<3; n1++) { | |
955 | n2=Pourcent3[n1+1]; | |
47cbf134 | 956 | voo[n1]=IntPatch_PolyhedronTool::Point(FirstPol, OI[n2]).XYZ()- |
957 | IntPatch_PolyhedronTool::Point(FirstPol, OI[n1]).XYZ(); | |
958 | vtt[n1]=IntPatch_PolyhedronTool::Point(SeconPol, TI[n2]).XYZ()- | |
959 | IntPatch_PolyhedronTool::Point(SeconPol, TI[n1]).XYZ(); | |
7fd59977 | 960 | } |
961 | ||
962 | gp_XYZ vvec=(voo[0]^voo[1])+(voo[1]^voo[2])+(voo[2]^voo[0]); | |
963 | gp_XYZ vnorT=(vtt[0]^vtt[1])+(vtt[1]^vtt[2])+(vtt[2]^vtt[0]); | |
964 | if (vnorT.Modulus()>vvec.Modulus()) | |
965 | vvec=vnorT; | |
966 | ||
967 | for (n1=0; n1<3; n1++) { | |
968 | ||
969 | for (n2=0; n2<3; n2++) { | |
970 | ||
47cbf134 | 971 | gp_XYZ vto=IntPatch_PolyhedronTool::Point(FirstPol, OI[n1]).XYZ()- |
972 | IntPatch_PolyhedronTool::Point(SeconPol, TI[n2]).XYZ(); | |
7fd59977 | 973 | dpOpT[n1][n2]=vto.Modulus(); |
974 | ||
975 | lg=vtt[n2].Modulus(); | |
976 | if (lg > 1e-16) { //-- RealEpsilon() | |
977 | gp_XYZ vv=vto^vtt[n2]; | |
978 | lg=(vvec*vv)>0.0 ? lg : -lg; | |
979 | dpOeT[n1][n2]=vv.Modulus()/lg; | |
980 | } | |
981 | else | |
982 | dpOeT[n1][n2]=dpOpT[n1][n2]; | |
983 | ||
984 | lg=voo[n1].Modulus(); | |
985 | if (lg > 1e-16) { //-- RealEpsilon()) | |
986 | gp_XYZ vv=vto^voo[n1]; | |
987 | lg=(vvec*vv)>0.0 ? -lg : lg; | |
988 | deOpT[n1][n2]=vv.Modulus()/lg; | |
989 | } | |
990 | else | |
991 | deOpT[n1][n2]=dpOpT[n1][n2]; | |
992 | } | |
993 | } | |
7fd59977 | 994 | } |