Commit | Line | Data |
---|---|---|
7fd59977 | 1 | // File: ApproxInt_MultiLine.gxx |
2 | // Created: Wed Mar 22 9:55:23 1993 | |
3 | // Author: Laurent BUCHARD | |
4 | // <lbr@topsn3> | |
5 | ||
6 | #define DEBUG 0 | |
7 | ||
8 | ||
9 | #include <TColStd_Array1OfReal.hxx> | |
10 | #include <IntSurf_LineOn2S.hxx> | |
11 | #include <gp_Pnt2d.hxx> | |
12 | #include <gp_Pnt.hxx> | |
13 | #include <gp_Vec2d.hxx> | |
14 | #include <gp_Vec.hxx> | |
15 | ||
16 | ApproxInt_MultiLine::ApproxInt_MultiLine(const Handle_TheLine& line, | |
17 | const Standard_Address svsurf, | |
18 | const Standard_Integer NbP3d, | |
19 | const Standard_Integer NbP2d, | |
20 | const Standard_Real xo, | |
21 | const Standard_Real ax, | |
22 | const Standard_Real yo, | |
23 | const Standard_Real ay, | |
24 | const Standard_Real zo, | |
25 | const Standard_Real az, | |
26 | const Standard_Real u1o, | |
27 | const Standard_Real a1u, | |
28 | const Standard_Real v1o, | |
29 | const Standard_Real a1v, | |
30 | const Standard_Real u2o, | |
31 | const Standard_Real a2u, | |
32 | const Standard_Real v2o, | |
33 | const Standard_Real a2v, | |
34 | const Standard_Boolean P2DOnFirst, | |
35 | const Standard_Integer IndMin, | |
36 | const Standard_Integer IndMax): | |
37 | ||
38 | PtrOnmySvSurfaces(svsurf), | |
39 | myLine(line), | |
40 | indicemin(IndMin), | |
41 | indicemax(IndMax), | |
42 | nbp3d(NbP3d), | |
43 | nbp2d(NbP2d), | |
44 | p2donfirst(P2DOnFirst), | |
45 | Xo(xo),Ax(ax),Yo(yo),Ay(ay),Zo(zo),Az(az), | |
46 | U1o(u1o),A1u(a1u),V1o(v1o),A1v(a1v), | |
47 | U2o(u2o),A2u(a2u),V2o(v2o),A2v(a2v) | |
48 | { | |
49 | #if DEBUG | |
50 | if(indicemin>=indicemax) { | |
51 | cout<<"\n********************************************"; | |
52 | cout<<"\n***** ApproxInt_MultiLine ********"; | |
53 | cout<<"\n***** indicemin = indicemax = "<<indicemin; | |
54 | cout<<"\n********************************************"<<endl; | |
55 | ||
56 | } | |
57 | #endif | |
58 | } | |
59 | //-------------------------------------------------------------------------------- | |
60 | ApproxInt_MultiLine::ApproxInt_MultiLine(const Handle_TheLine& line, | |
61 | const Standard_Integer NbP3d, | |
62 | const Standard_Integer NbP2d, | |
63 | const Standard_Real xo, | |
64 | const Standard_Real ax, | |
65 | const Standard_Real yo, | |
66 | const Standard_Real ay, | |
67 | const Standard_Real zo, | |
68 | const Standard_Real az, | |
69 | const Standard_Real u1o, | |
70 | const Standard_Real a1u, | |
71 | const Standard_Real v1o, | |
72 | const Standard_Real a1v, | |
73 | const Standard_Real u2o, | |
74 | const Standard_Real a2u, | |
75 | const Standard_Real v2o, | |
76 | const Standard_Real a2v, | |
77 | const Standard_Boolean P2DOnFirst, | |
78 | const Standard_Integer IndMin, | |
79 | const Standard_Integer IndMax): | |
80 | ||
81 | PtrOnmySvSurfaces(0), | |
82 | myLine(line), | |
83 | indicemin(IndMin), | |
84 | indicemax(IndMax), | |
85 | nbp3d(NbP3d), | |
86 | nbp2d(NbP2d), | |
87 | p2donfirst(P2DOnFirst), | |
88 | Xo(xo),Ax(ax),Yo(yo),Ay(ay),Zo(zo),Az(az), | |
89 | U1o(u1o),A1u(a1u),V1o(v1o),A1v(a1v), | |
90 | U2o(u2o),A2u(a2u),V2o(v2o),A2v(a2v) | |
91 | { | |
92 | if(indicemin>=indicemax) { | |
93 | #if DEBUG | |
94 | cout<<"\n********************************************"; | |
95 | cout<<"\n***** ApproxInt_MultiLine ********"; | |
96 | cout<<"\n***** indicemin = indicemax = "<<indicemin; | |
97 | cout<<"\n********************************************"<<endl; | |
98 | #endif | |
99 | } | |
100 | } | |
101 | //-------------------------------------------------------------------------------- | |
102 | Standard_Integer ApproxInt_MultiLine::FirstPoint() const { | |
103 | return(indicemin); | |
104 | } | |
105 | //-------------------------------------------------------------------------------- | |
106 | Standard_Integer ApproxInt_MultiLine::LastPoint() const { | |
107 | return(indicemax); | |
108 | } | |
109 | //-------------------------------------------------------------------------------- | |
110 | Approx_Status ApproxInt_MultiLine::WhatStatus() const { | |
111 | if(PtrOnmySvSurfaces) | |
112 | return(Approx_PointsAdded); | |
113 | else | |
114 | return(Approx_NoPointsAdded); | |
115 | } | |
116 | //-------------------------------------------------------------------------------- | |
117 | Standard_Integer ApproxInt_MultiLine::NbP3d() const { | |
118 | return(nbp3d); | |
119 | } | |
120 | //-------------------------------------------------------------------------------- | |
121 | Standard_Integer ApproxInt_MultiLine::NbP2d() const { | |
122 | return(nbp2d); | |
123 | } | |
124 | //================================================================================ | |
125 | void ApproxInt_MultiLine::Value(const Standard_Integer Index, | |
126 | TColgp_Array1OfPnt& TabPnt) const | |
127 | { | |
128 | IntSurf_PntOn2S POn2S(myLine->Point(Index)); | |
129 | Standard_Real X = POn2S.Value().X(); | |
130 | Standard_Real Y = POn2S.Value().Y(); | |
131 | Standard_Real Z = POn2S.Value().Z(); | |
132 | TabPnt(1) = gp_Pnt(X*Ax + Xo, Y*Ay + Yo, Z*Az + Zo); | |
133 | } | |
134 | //-------------------------------------------------------------------------------- | |
135 | void ApproxInt_MultiLine::Value( const Standard_Integer Index | |
136 | ,TColgp_Array1OfPnt2d& TabPnt2d) const | |
137 | { | |
138 | IntSurf_PntOn2S POn2S(myLine->Point(Index)); | |
139 | Standard_Real u1,u2,v1,v2; | |
140 | POn2S.Parameters(u1,v1,u2,v2); | |
141 | if(nbp2d==1) { | |
142 | if(p2donfirst) { | |
143 | TabPnt2d(1) = gp_Pnt2d(u1 * A1u + U1o , v1 * A1v + V1o); | |
144 | } | |
145 | else { | |
146 | TabPnt2d(1) = gp_Pnt2d(u2 * A2u + U2o , v2 * A2v + V2o); | |
147 | } | |
148 | } | |
149 | else { | |
150 | TabPnt2d(1) = gp_Pnt2d(u1 * A1u + U1o , v1 * A1v + V1o); | |
151 | if(TabPnt2d.Length()>=2) { | |
152 | TabPnt2d(2) = gp_Pnt2d(u2 * A2u + U2o , v2 * A2v + V2o); | |
153 | } | |
154 | } | |
155 | } | |
156 | //-------------------------------------------------------------------------------- | |
157 | void ApproxInt_MultiLine::Value( const Standard_Integer Index | |
158 | ,TColgp_Array1OfPnt& TabPnt | |
159 | ,TColgp_Array1OfPnt2d& TabPnt2d) const | |
160 | { | |
161 | IntSurf_PntOn2S POn2S(myLine->Point(Index)); | |
162 | Standard_Real u1,u2,v1,v2; | |
163 | POn2S.Parameters(u1,v1,u2,v2); | |
164 | if(nbp2d==1) { | |
165 | if(p2donfirst) { | |
166 | TabPnt2d(1) = gp_Pnt2d(u1 * A1u + U1o , v1 * A1v + V1o); | |
167 | } | |
168 | else { | |
169 | TabPnt2d(1) = gp_Pnt2d(u2 * A2u + U2o , v2 * A2v + V2o); | |
170 | } | |
171 | } | |
172 | else { | |
173 | TabPnt2d(1) = gp_Pnt2d(u1 * A1u + U1o , v1 * A1v + V1o); | |
174 | if(TabPnt2d.Length()>=2) { | |
175 | TabPnt2d(2) = gp_Pnt2d(u2 * A2u + U2o , v2 * A2v + V2o); | |
176 | } | |
177 | } | |
178 | Standard_Real X = POn2S.Value().X(); | |
179 | Standard_Real Y = POn2S.Value().Y(); | |
180 | Standard_Real Z = POn2S.Value().Z(); | |
181 | TabPnt(1) = gp_Pnt(X * Ax + Xo, Y * Ay + Yo, Z * Az + Zo); | |
182 | } | |
183 | //-------------------------------------------------------------------------------- | |
184 | //-------------------------------------------------------------------------------- | |
185 | Standard_Boolean ApproxInt_MultiLine::Tangency( const Standard_Integer Index | |
186 | ,TColgp_Array1OfVec& TabVec) const | |
187 | { | |
188 | if(PtrOnmySvSurfaces==NULL) | |
189 | return(Standard_False); | |
190 | ||
191 | IntSurf_PntOn2S POn2S(myLine->Point(Index)); | |
192 | Standard_Real u1,u2,v1,v2; | |
193 | gp_Vec Tg; | |
194 | POn2S.Parameters(u1,v1,u2,v2); | |
195 | Standard_Boolean ret=((TheSvSurfaces *)PtrOnmySvSurfaces)->Tangency( u1,v1,u2,v2,Tg); | |
196 | if(ret) { | |
197 | Standard_Real X = Tg.X(); | |
198 | Standard_Real Y = Tg.Y(); | |
199 | Standard_Real Z = Tg.Z(); | |
200 | TabVec(1) = gp_Vec(X * Ax, Y * Ay, Z * Az); | |
201 | } | |
202 | else | |
203 | TabVec(1) = gp_Vec(0.0,0.0,0.0); | |
204 | return(ret); | |
205 | } | |
206 | //-------------------------------------------------------------------------------- | |
207 | Standard_Boolean ApproxInt_MultiLine::Tangency( const Standard_Integer Index | |
208 | ,TColgp_Array1OfVec2d& TabVec2d) const | |
209 | { | |
210 | if(PtrOnmySvSurfaces==NULL) | |
211 | return(Standard_False); | |
212 | ||
213 | IntSurf_PntOn2S POn2S(myLine->Point(Index)); | |
214 | Standard_Real u1,u2,v1,v2,U,V; | |
215 | gp_Vec2d Tg2d; | |
216 | Standard_Boolean ret; | |
217 | POn2S.Parameters(u1,v1,u2,v2); | |
218 | if(nbp2d==1) { | |
219 | Standard_Real Au = A1u; | |
220 | Standard_Real Av = A1v; | |
221 | if(p2donfirst) { | |
222 | ret=((TheSvSurfaces *)PtrOnmySvSurfaces)->TangencyOnSurf1( u1,v1,u2,v2,Tg2d); | |
223 | } | |
224 | else { | |
225 | ret=((TheSvSurfaces *)PtrOnmySvSurfaces)->TangencyOnSurf2( u1,v1,u2,v2,Tg2d); | |
226 | Au = A2u; | |
227 | Av = A2v; | |
228 | } | |
229 | if(ret) { | |
230 | U = Tg2d.X(); | |
231 | V = Tg2d.Y(); | |
232 | TabVec2d(1) = gp_Vec2d(U * Au, V * Av); | |
233 | } | |
234 | else { | |
235 | TabVec2d(1) = gp_Vec2d(0.0,0.0); | |
236 | } | |
237 | } | |
238 | else { | |
239 | ret=((TheSvSurfaces *)PtrOnmySvSurfaces)->TangencyOnSurf1( u1,v1,u2,v2,Tg2d); | |
240 | if(ret) { | |
241 | U = Tg2d.X(); | |
242 | V = Tg2d.Y(); | |
243 | TabVec2d(1) = gp_Vec2d(U * A1u, V * A1v); | |
244 | ||
245 | if(TabVec2d.Length()>=2) { | |
246 | ret&=((TheSvSurfaces *)PtrOnmySvSurfaces)->TangencyOnSurf2( u1,v1,u2,v2,Tg2d); | |
247 | U = Tg2d.X(); | |
248 | V = Tg2d.Y(); | |
249 | TabVec2d(2) = gp_Vec2d(U * A2u, V * A2v); | |
250 | } | |
251 | else { | |
252 | TabVec2d(1) = gp_Vec2d(0.0,0.0); | |
253 | if(TabVec2d.Length()>=2) { | |
254 | TabVec2d(2) = gp_Vec2d(0.0,0.0); | |
255 | } | |
256 | } | |
257 | } | |
258 | } | |
259 | return(ret); | |
260 | } | |
261 | //-------------------------------------------------------------------------------- | |
262 | Standard_Boolean ApproxInt_MultiLine::Tangency( const Standard_Integer Index | |
263 | ,TColgp_Array1OfVec& TabVec | |
264 | ,TColgp_Array1OfVec2d& TabVec2d) const | |
265 | { | |
266 | if(PtrOnmySvSurfaces==NULL) | |
267 | return(Standard_False); | |
268 | ||
269 | IntSurf_PntOn2S POn2S(myLine->Point(Index)); | |
270 | Standard_Real u1,u2,v1,v2,U,V; | |
271 | gp_Vec2d Tg2d; | |
272 | gp_Vec Tg; | |
273 | Standard_Boolean ret; | |
274 | POn2S.Parameters(u1,v1,u2,v2); | |
275 | if(nbp2d==1) { | |
276 | Standard_Real Au = A1u; | |
277 | Standard_Real Av = A1v; | |
278 | if(p2donfirst) { | |
279 | ret=((TheSvSurfaces *)PtrOnmySvSurfaces)->TangencyOnSurf1( u1,v1,u2,v2,Tg2d); | |
280 | } | |
281 | else { | |
282 | ret=((TheSvSurfaces *)PtrOnmySvSurfaces)->TangencyOnSurf2( u1,v1,u2,v2,Tg2d); | |
283 | Au = A2u; | |
284 | Av = A2v; | |
285 | } | |
286 | if(ret) { | |
287 | U = Tg2d.X(); | |
288 | V = Tg2d.Y(); | |
289 | TabVec2d(1) = gp_Vec2d(U * Au, V * Av); | |
290 | } | |
291 | else { | |
292 | TabVec2d(1) = gp_Vec2d(0.0,0.0); | |
293 | } | |
294 | } | |
295 | else { | |
296 | ret=((TheSvSurfaces *)PtrOnmySvSurfaces)->TangencyOnSurf1( u1,v1,u2,v2,Tg2d); | |
297 | if(ret) { | |
298 | U = Tg2d.X(); | |
299 | V = Tg2d.Y(); | |
300 | TabVec2d(1) = gp_Vec2d(U * A1u, V * A1v); | |
301 | if(TabVec2d.Length()>=2) { | |
302 | ret&=((TheSvSurfaces *)PtrOnmySvSurfaces)->TangencyOnSurf2( u1,v1,u2,v2,Tg2d); | |
303 | U = Tg2d.X(); | |
304 | V = Tg2d.Y(); | |
305 | TabVec2d(2) = gp_Vec2d(U * A2u, V * A2v); | |
306 | } | |
307 | } | |
308 | else { | |
309 | TabVec2d(1) = gp_Vec2d(0.0,0.0); | |
310 | if(TabVec2d.Length()>=2) { | |
311 | TabVec2d(2) = gp_Vec2d(0.0,0.0); | |
312 | } | |
313 | } | |
314 | } | |
315 | if(ret) { | |
316 | ret&=((TheSvSurfaces *)PtrOnmySvSurfaces)->Tangency( u1,v1,u2,v2,Tg); | |
317 | Standard_Real X = Tg.X(); | |
318 | Standard_Real Y = Tg.Y(); | |
319 | Standard_Real Z = Tg.Z(); | |
320 | TabVec(1) = gp_Vec(X * Ax, Y * Ay, Z * Az); | |
321 | } | |
322 | else { | |
323 | TabVec(1) = gp_Vec(0.0,0.0,0.0); | |
324 | } | |
325 | return(ret); | |
326 | } | |
327 | //-------------------------------------------------------------------------------- | |
328 | ||
329 | ||
330 | ||
331 | //================================================================================ | |
332 | ApproxInt_MultiLine ApproxInt_MultiLine::MakeMLBetween(const Standard_Integer Low, | |
333 | const Standard_Integer High, | |
334 | const Standard_Integer aNbPntsToInsert) | |
335 | const { | |
336 | if(PtrOnmySvSurfaces==NULL) { | |
337 | //-- cout<<"\n Erreur dans : ApproxInt_MultiLine ApproxInt_MultiLine::MakeMLBetween "<<endl; | |
338 | Handle(IntSurf_LineOn2S) vide1 = new IntSurf_LineOn2S(); | |
339 | Handle(TheLine) vide = new TheLine(vide1,Standard_False); | |
340 | return(ApproxInt_MultiLine(vide, | |
341 | NULL, | |
342 | nbp3d, | |
343 | nbp2d, | |
344 | Xo,Ax,Yo,Ay,Zo,Az, | |
345 | U1o,A1u,V1o,A1v, | |
346 | U2o,A2u,V2o,A2v, | |
347 | p2donfirst, | |
348 | 1,1)); | |
349 | //-- return(*this); | |
350 | } | |
351 | Standard_Integer NbPntsToInsert=aNbPntsToInsert; | |
352 | if(NbPntsToInsert<(High-Low)) NbPntsToInsert=(High-Low); | |
353 | Standard_Integer NbPnts = NbPntsToInsert + High - Low + 1; | |
354 | Standard_Integer NbPntsmin = High-Low; | |
355 | NbPntsmin+=NbPntsmin; | |
356 | ||
357 | if(NbPnts<NbPntsmin) NbPnts=NbPntsmin; | |
358 | ||
359 | ||
360 | gp_Vec T; | |
361 | gp_Vec2d TS1,TS2; | |
362 | gp_Pnt P; | |
363 | ||
364 | //-----------------------l------------------------------------------- | |
365 | //-- Indice : Low Low+1 I I+1 High -- | |
366 | //-- -- | |
367 | //-- Abs.Curv. : S(Low) S(I) S(I+1) S(High) -- | |
368 | //-- -- | |
369 | //-- On echantillonne a abcisse curviligne -- | |
370 | //-- constante. -- | |
371 | //-- L abcisse est calculee sur les params U1,V1 -- | |
372 | //------------------------------------------------------------------ | |
373 | TColStd_Array1OfReal U1(Low,High); | |
374 | TColStd_Array1OfReal V1(Low,High); | |
375 | TColStd_Array1OfReal U2(Low,High); | |
376 | TColStd_Array1OfReal V2(Low,High); | |
377 | TColStd_Array1OfReal AC(Low,High); | |
378 | Standard_Real s,ds; | |
379 | ||
380 | //------------------------------------------------------------ | |
381 | //-- Creation des Tableaux U1 .. V2 et AC | |
382 | //-- | |
383 | Standard_Real u1,v1,u2,v2; | |
384 | Standard_Integer i ; | |
385 | myLine->Point(Low).Parameters(u1,v1,u2,v2); | |
386 | U1(Low) = u1; | |
387 | V1(Low) = v1; | |
388 | U2(Low) = u2; | |
389 | V2(Low) = v2; | |
390 | AC(Low) =0.0; | |
391 | ||
392 | #if 0 | |
393 | ||
394 | for( i=Low+1; i<=High; i++) { | |
395 | myLine->Point(i).Parameters(u1,v1,u2,v2); | |
396 | U1(i) = u1; | |
397 | V1(i) = v1; | |
398 | U2(i) = u2; | |
399 | V2(i) = v2; | |
400 | ||
401 | Standard_Real du1=u1-U1(i-1); | |
402 | Standard_Real dv1=v1-V1(i-1); | |
403 | ||
404 | AC(i) = AC(i-1) + sqrt((du1*du1)+(dv1*dv1)); | |
405 | } | |
406 | #else | |
407 | //-- Essai du 19 juin 96 (parametrage selon abs curv en XYZ) | |
408 | for( i=Low+1; i<=High; i++) { | |
409 | myLine->Point(i).Parameters(u1,v1,u2,v2); | |
410 | U1(i) = u1; | |
411 | V1(i) = v1; | |
412 | U2(i) = u2; | |
413 | V2(i) = v2; | |
414 | AC(i) = AC(i-1) | |
415 | + (myLine->Point(i-1).Value()).Distance(myLine->Point(i).Value()); | |
416 | } | |
417 | ||
418 | #endif | |
419 | //------------------------------------------------------------- | |
420 | //-- Creation des structures contenant les resultats | |
421 | ||
422 | Handle(IntSurf_LineOn2S) ResultPntOn2SLine | |
423 | = new IntSurf_LineOn2S(); | |
424 | ||
425 | IntSurf_PntOn2S StartPOn2S; | |
426 | TColStd_Array1OfReal StartParams(1,4); | |
427 | ||
428 | ||
429 | ds = AC(High) / (NbPnts-1); | |
430 | Standard_Integer Indice = Low; | |
431 | Standard_Boolean HasBeenInserted = Standard_False; | |
432 | Standard_Real dsmin = ds*0.3; | |
433 | Standard_Real smax = AC(High); | |
434 | ||
39408dc0 | 435 | for(i=2,s=ds; (s < smax && Indice <= High-1); i++,s+=ds) { |
7fd59977 | 436 | //---------------------------------------------------------- |
437 | //-- Recherche des indices des points -- | |
438 | //-- Point : 2 i NbPnts-1 -- | |
439 | //-- s s -- | |
440 | //-- Current Indice tel que AC(Indice)<= s < AC(Indice+1) -- | |
441 | //---------------------------------------------------------- | |
442 | while(AC(Indice+1) <= s) { | |
443 | if(!HasBeenInserted) ResultPntOn2SLine->Add(myLine->Point(Indice)); | |
444 | HasBeenInserted = Standard_False; | |
445 | Indice++; | |
39408dc0 J |
446 | if (Indice == High) |
447 | break; | |
7fd59977 | 448 | } |
39408dc0 J |
449 | |
450 | if (Indice == High) | |
451 | break; | |
452 | ||
7fd59977 | 453 | if(!HasBeenInserted && AC(Indice) <= s) { |
454 | ResultPntOn2SLine->Add(myLine->Point(Indice)); | |
455 | HasBeenInserted = Standard_True; | |
456 | } | |
457 | Standard_Real a = s - AC(Indice); | |
458 | Standard_Real b = AC(Indice+1) - s; | |
459 | Standard_Real nab = 1.0/(a+b); | |
460 | ||
461 | //---------------------------------------------------------- | |
462 | //-- Verification : Si Dist au prochain point < dsmin -- | |
463 | //-- Si Dist au precedent point < dsmin -- | |
464 | //-- -- | |
465 | //---------------------------------------------------------- | |
466 | if((a>dsmin) && (b>dsmin)) { | |
467 | ||
468 | u1 = (U1(Indice) * b + U1(Indice+1) * a) * nab; | |
469 | v1 = (V1(Indice) * b + V1(Indice+1) * a) * nab; | |
470 | u2 = (U2(Indice) * b + U2(Indice+1) * a) * nab; | |
471 | v2 = (V2(Indice) * b + V2(Indice+1) * a) * nab; | |
472 | ||
473 | ||
474 | if(((TheSvSurfaces *)PtrOnmySvSurfaces)->Compute(u1,v1,u2,v2,P,T,TS1,TS2)) { | |
475 | StartPOn2S.SetValue(P,u1,v1,u2,v2); | |
476 | //-- cout<<" Insertion du point calcule : "<<u1<<","<<v1<<","<<u2<<","<<v2<<","; | |
477 | //-- cout<<P.X()<<","<<P.Y()<<","<<P.Z()<<endl; | |
478 | ResultPntOn2SLine->Add(StartPOn2S); | |
479 | } | |
480 | else { | |
481 | //-- cout<<" Probleme Non Traite ds ApproxInt_ApproxIntIntersection "<<endl; | |
482 | } | |
483 | } | |
484 | else { | |
485 | //-- Point non situe a distance suffisante de 2 pts existants | |
486 | //-- avec le point p[indice] deja insere | |
487 | ||
488 | if(b<0.0) { | |
489 | while(AC(Indice+1) <= s) { | |
490 | if(!HasBeenInserted) ResultPntOn2SLine->Add(myLine->Point(Indice)); | |
491 | //-- cout<<" Insertion du point :"<<Indice<<endl; | |
492 | HasBeenInserted = Standard_False; | |
493 | Indice++; | |
39408dc0 J |
494 | if (Indice == High) |
495 | break; | |
7fd59977 | 496 | } |
39408dc0 J |
497 | |
498 | if (Indice == High) | |
499 | break; | |
500 | ||
7fd59977 | 501 | if(!HasBeenInserted && AC(Indice) <= s) { |
502 | ResultPntOn2SLine->Add(myLine->Point(Indice)); | |
503 | HasBeenInserted = Standard_True; | |
504 | } | |
505 | } | |
506 | else { | |
507 | s+=dsmin - ds; | |
508 | } | |
509 | } | |
510 | } | |
511 | ||
512 | ResultPntOn2SLine->Add(myLine->Point(High)); //-- Point NbPnts | |
513 | Handle(TheLine) temp = new TheLine(ResultPntOn2SLine,Standard_False); | |
514 | ||
515 | //-- Verification a posteriori | |
516 | //-- On verifie qu il n y a pas de virage trop important en 2d et en 3d | |
517 | ||
518 | temp->Point(1).Parameters(u1,v1,u2,v2); | |
519 | gp_Pnt2d P1A(u1,v1); | |
520 | gp_Pnt2d P2A(u2,v2); | |
521 | ||
522 | temp->Point(2).Parameters(u1,v1,u2,v2); | |
523 | gp_Pnt2d P1B(u1,v1); | |
524 | gp_Pnt2d P2B(u2,v2); | |
525 | ||
526 | gp_Pnt2d P1C,P2C; | |
527 | ||
528 | Standard_Integer CodeErreur=0; | |
529 | ||
530 | for(i=3,NbPnts=temp->NbPnts();CodeErreur==0 && i<=NbPnts; i++) { | |
531 | Standard_Real d,du,dv,duv2; | |
532 | temp->Point(i).Parameters(u1,v1,u2,v2); | |
533 | //-- Virage P1A P1B P1C | |
534 | P1C.SetCoord(u1,v1); | |
535 | du = P1B.X()-P1A.X(); | |
536 | dv = P1B.Y()-P1A.Y(); | |
537 | duv2= 0.25*(du*du+dv*dv); | |
538 | u1 = P1B.X() + du; | |
539 | v1 = P1B.Y() + dv; | |
540 | du = P1C.X() - u1; | |
541 | dv = P1C.Y() - v1; | |
542 | d = du*du+dv*dv; | |
543 | if(d>duv2) { | |
544 | CodeErreur = 1; | |
545 | CodeErreur = 1; | |
546 | break; | |
547 | } | |
548 | //-- Virage P2A P2B P2C | |
549 | P2C.SetCoord(u2,v2); | |
550 | du = P2B.X()-P2A.X(); | |
551 | dv = P2B.Y()-P2A.Y(); | |
552 | duv2= 0.25*(du*du+dv*dv); | |
553 | u2 = P2B.X() + du; | |
554 | v2 = P2B.Y() + dv; | |
555 | du = P2C.X() - u2; | |
556 | dv = P2C.Y() - v2; | |
557 | d = du*du+dv*dv; | |
558 | if(d>duv2) { | |
559 | CodeErreur = 2; | |
560 | break; | |
561 | } | |
562 | P1A=P1B; | |
563 | P2A=P2B; | |
564 | P1B=P1C; | |
565 | P2B=P2C; | |
566 | } | |
567 | #if DEBUG | |
568 | if (temp->NbPnts() < NbPntsToInsert + High - Low + 1) { | |
569 | cout<<" *** Pas assez de points entre :"<<Low<<" et "<<High<<" -> "<<temp->NbPnts()<<endl; | |
570 | } | |
571 | if(CodeErreur) { | |
572 | cout<<" *** CodeErreur : "<<CodeErreur<<endl; | |
573 | } | |
574 | #endif | |
575 | if((temp->NbPnts() >= NbPntsToInsert + High - Low + 1) | |
576 | && (CodeErreur==0)) { | |
577 | return(ApproxInt_MultiLine(temp, | |
578 | (High-Low>10)? PtrOnmySvSurfaces : NULL, | |
579 | nbp3d, | |
580 | nbp2d, | |
581 | Xo,Ax,Yo,Ay,Zo,Az, | |
582 | U1o,A1u,V1o,A1v, | |
583 | U2o,A2u,V2o,A2v, | |
584 | p2donfirst, | |
585 | 1,ResultPntOn2SLine->NbPoints())); | |
586 | } | |
587 | else { | |
588 | //-- cout<<" ApproxInt_MultiLine "<<endl; | |
589 | //-- cout<<" Pas de Rajout de points ds1min = "<<minds1<<" ds2min = "<<minds2<<endl; | |
590 | Handle(IntSurf_LineOn2S) vide1 = new IntSurf_LineOn2S(); | |
591 | Handle(TheLine) vide = new TheLine(vide1,Standard_False); | |
592 | return(ApproxInt_MultiLine(vide, | |
593 | NULL, | |
594 | nbp3d, | |
595 | nbp2d, | |
596 | Xo,Ax,Yo,Ay,Zo,Az, | |
597 | U1o,A1u,V1o,A1v, | |
598 | U2o,A2u,V2o,A2v, | |
599 | p2donfirst, | |
600 | 1,1)); | |
601 | } | |
602 | } | |
603 | //====================================================================== | |
604 |