7fd59977 |
1 | // File: GeomFill_GuideTrihedronPlan.cxx |
2 | // Created: Thu Jul 02 15:39:24 1998 |
3 | // Author: Stephanie HUMEAU |
4 | // <shu@sun17> |
5 | |
6 | |
7 | #include <GeomFill_GuideTrihedronPlan.ixx> |
8 | |
9 | #include <gp_Pnt.hxx> |
10 | #include <gp_Pnt2d.hxx> |
11 | //#include <gp_Trsf2d.hxx> |
12 | //#include <Bnd_Box2d.hxx> |
13 | #include <ElCLib.hxx> |
14 | |
15 | #include <Adaptor3d_Curve.hxx> |
16 | #include <GeomAdaptor_HCurve.hxx> |
17 | #include <GeomAdaptor_HSurface.hxx> |
18 | |
19 | #include <Geom_Plane.hxx> |
20 | |
21 | #include <IntCurveSurface_IntersectionPoint.hxx> |
22 | #include <IntCurveSurface_HInter.hxx> |
23 | |
24 | #include <GeomFill_Frenet.hxx> |
25 | #include <GeomFill_PlanFunc.hxx> |
26 | |
27 | #include <math_Vector.hxx> |
28 | |
29 | #include <math_FunctionRoot.hxx> |
30 | #include <math_Matrix.hxx> |
31 | |
32 | #include <Precision.hxx> |
33 | |
34 | #if DRAW |
35 | #include <DrawTrSurf.hxx> |
36 | #endif |
37 | |
38 | #if DEB |
39 | static void TracePlan(const Handle(Geom_Surface)& Plan) |
40 | { |
41 | cout << "Pas d'intersection Guide/Plan" << endl; |
42 | #if DRAW |
43 | char* Temp = "ThePlan" ; |
44 | DrawTrSurf::Set(Temp, Plan); |
45 | // DrawTrSurf::Set("ThePlan", Plan); |
46 | #endif |
47 | } |
48 | #endif |
49 | |
50 | //================================================================== |
51 | //Function: InGoodPeriod |
52 | //Purpose : Recadre un paramtere |
53 | //================================================================== |
54 | static void InGoodPeriod(const Standard_Real Prec, |
55 | const Standard_Real Period, |
56 | Standard_Real& Current) |
57 | { |
58 | Standard_Real Diff=Current-Prec; |
59 | Standard_Integer nb = (Standard_Integer ) IntegerPart(Diff/Period); |
60 | Current -= nb*Period; |
61 | Diff = Current-Prec; |
62 | if (Diff > Period/2) Current -= Period; |
63 | else if (Diff < -Period/2) Current += Period; |
64 | } |
65 | |
66 | //======================================================================= |
67 | //function : GuideTrihedronPlan |
68 | //purpose : Constructor |
69 | //======================================================================= |
70 | GeomFill_GuideTrihedronPlan::GeomFill_GuideTrihedronPlan (const Handle(Adaptor3d_HCurve)& theGuide) : |
71 | X(1,1), |
72 | XTol(1,1), |
73 | Inf(1,1), Sup(1,1), |
74 | myStatus(GeomFill_PipeOk) |
75 | { |
76 | myCurve.Nullify(); |
77 | myGuide = theGuide; // guide |
78 | myTrimG = theGuide; |
79 | myNbPts = 20; // nb points pour calculs |
80 | Pole = new (TColgp_HArray2OfPnt2d)(1,1,1,myNbPts);//tab pr stocker Pprime (pt sur guide) |
81 | frenet = new (GeomFill_Frenet)(); |
82 | XTol.Init(1.e-6); |
83 | XTol(1) = myGuide->Resolution(1.e-6); |
84 | } |
85 | |
86 | //======================================================================= |
87 | //function : Init |
88 | //purpose : calcule myNbPts points sur la courbe guide (<=> normale) |
89 | //======================================================================= |
90 | void GeomFill_GuideTrihedronPlan::Init() |
91 | { |
92 | myStatus = GeomFill_PipeOk; |
93 | gp_Pnt P; |
94 | // Bnd_Box2d Box; |
95 | // Box.Update(-0.1, -0.1, 0.1, 0.1); // Taille minimal |
96 | gp_Vec Tangent,Normal,BiNormal; |
97 | Standard_Integer ii; |
98 | Standard_Real t, DeltaG, w; |
99 | Standard_Real f = myCurve->FirstParameter(); |
100 | Standard_Real l = myCurve->LastParameter(); |
101 | |
102 | |
103 | |
104 | Handle(Geom_Plane) Plan; |
105 | Handle(GeomAdaptor_HSurface) Pl; |
106 | IntCurveSurface_IntersectionPoint PInt; |
107 | IntCurveSurface_HInter Int; |
108 | frenet->SetCurve(myCurve); |
109 | DeltaG = (myGuide->LastParameter() - myGuide->FirstParameter())/2; |
110 | |
111 | Inf(1) = myGuide->FirstParameter() - DeltaG; |
112 | Sup(1) = myGuide->LastParameter() + DeltaG; |
113 | |
114 | if (!myGuide->IsPeriodic()) { |
115 | myTrimG = myGuide->Trim(myGuide->FirstParameter()- DeltaG/100, |
116 | myGuide->LastParameter() + DeltaG/100, |
117 | DeltaG*1.e-7); |
118 | } |
119 | else { |
120 | myTrimG = myGuide; |
121 | } |
122 | // Standard_Real Step = DeltaG/100; |
123 | DeltaG /= 3; |
124 | for (ii=1; ii<=myNbPts; ii++) |
125 | { |
126 | t = Standard_Real(myNbPts - ii)*f + Standard_Real(ii - 1)*l; |
127 | t /= (myNbPts-1); |
128 | myCurve->D0(t, P); |
129 | frenet->D0(t, Tangent, Normal, BiNormal); |
130 | Plan = new (Geom_Plane) (P, Tangent); |
131 | Pl = new(GeomAdaptor_HSurface) (Plan); |
132 | |
133 | Int.Perform(myTrimG, Pl); // intersection plan / guide |
134 | if (Int.NbPoints() == 0) { |
135 | #if DEB |
136 | TracePlan(Plan); |
137 | #endif |
138 | w = (fabs(myGuide->LastParameter() -w) > fabs(myGuide->FirstParameter()-w) ? myGuide->FirstParameter() : myGuide->LastParameter()); |
139 | |
140 | myStatus = GeomFill_PlaneNotIntersectGuide; |
141 | //return; |
142 | } |
143 | else |
144 | { |
145 | gp_Pnt Pmin; |
146 | PInt = Int.Point(1); |
147 | Pmin = PInt.Pnt(); |
148 | Standard_Real Dmin = P.Distance(Pmin); |
149 | for (Standard_Integer jj=2;jj<=Int.NbPoints();jj++) |
150 | { |
151 | Pmin = Int.Point(jj).Pnt(); |
152 | if (P.Distance(Pmin) < Dmin) |
153 | { |
154 | PInt = Int.Point(jj); |
155 | Dmin = P.Distance(Pmin); |
156 | } |
157 | }//for_jj |
158 | |
159 | w = PInt.W(); |
160 | } |
161 | if (ii>1) { |
162 | Standard_Real Diff = w - Pole->Value(1, ii-1).Y(); |
163 | if (Abs(Diff) > DeltaG) { |
164 | if (myGuide->IsPeriodic()) { |
165 | InGoodPeriod (Pole->Value(1, ii-1).Y(), |
166 | myGuide->Period(), w); |
167 | |
168 | Diff = w - Pole->Value(1, ii-1).Y(); |
169 | } |
170 | } |
171 | |
172 | #if DEB |
173 | if (Abs(Diff) > DeltaG) { |
174 | cout << "Trihedron Plan Diff on Guide : " << |
175 | Diff << endl; |
176 | } |
177 | #endif |
178 | } |
179 | |
180 | gp_Pnt2d p1(t, w); // on stocke les parametres |
181 | Pole->SetValue(1, ii, p1); |
182 | |
183 | }// for_ii |
184 | } |
185 | |
186 | //======================================================================= |
187 | //function : SetCurve |
188 | //purpose : calculation of trihedron |
189 | //======================================================================= |
190 | void GeomFill_GuideTrihedronPlan::SetCurve(const Handle(Adaptor3d_HCurve)& C) |
191 | { |
192 | myCurve = C; |
193 | if (!myCurve.IsNull()) Init(); |
194 | } |
195 | |
196 | //======================================================================= |
197 | //function : Guide |
198 | //purpose : calculation of trihedron |
199 | //======================================================================= |
200 | |
201 | Handle(Adaptor3d_HCurve) GeomFill_GuideTrihedronPlan::Guide()const |
202 | { |
203 | return myGuide; |
204 | } |
205 | |
206 | //======================================================================= |
207 | //function : D0 |
208 | //purpose : calculation of trihedron |
209 | //======================================================================= |
210 | Standard_Boolean GeomFill_GuideTrihedronPlan::D0(const Standard_Real Param, |
211 | gp_Vec& Tangent, |
212 | gp_Vec& Normal, |
213 | gp_Vec& BiNormal) |
214 | { |
215 | gp_Pnt P, Pprime; |
216 | // gp_Vec To; |
217 | |
218 | myCurve->D0(Param, P); |
219 | |
220 | frenet->D0(Param,Tangent,Normal,BiNormal); |
221 | |
222 | //initialisation de la recherche |
223 | InitX(Param); |
224 | |
225 | Standard_Integer Iter = 50; |
226 | |
227 | // fonction dont il faut trouver la racine : G(W)-Pl(U,V)=0 |
228 | GeomFill_PlanFunc E(P, Tangent, myGuide); |
229 | |
230 | // resolution |
231 | math_FunctionRoot Result(E, X(1), XTol(1), |
232 | Inf(1), Sup(1), Iter); |
233 | |
234 | if (Result.IsDone()) |
235 | { |
236 | Standard_Real Res = Result.Root(); |
237 | // R = Result.Root(); // solution |
238 | |
239 | Pprime = myTrimG->Value(Res); // pt sur courbe guide |
240 | gp_Vec n (P, Pprime); // vecteur definissant la normale du triedre |
241 | |
242 | Normal = n.Normalized(); |
243 | BiNormal = Tangent.Crossed(Normal); |
244 | BiNormal.Normalized(); |
245 | } |
246 | else { // Erreur... |
247 | #if DEB |
248 | cout << "D0 :"; |
249 | // plan ortho a la trajectoire pour determiner Pprime |
250 | Handle(Geom_Plane) Plan = new (Geom_Plane)(P, Tangent); |
251 | TracePlan(Plan); |
252 | #endif |
253 | myStatus = GeomFill_PlaneNotIntersectGuide; |
254 | return Standard_False; |
255 | } |
256 | |
257 | return Standard_True; |
258 | } |
259 | |
260 | //======================================================================= |
261 | //function : D1 |
262 | //purpose : calculation of trihedron and first derivative |
263 | //======================================================================= |
264 | Standard_Boolean GeomFill_GuideTrihedronPlan::D1(const Standard_Real Param, |
265 | gp_Vec& Tangent, |
266 | gp_Vec& DTangent, |
267 | gp_Vec& Normal, |
268 | gp_Vec& DNormal, |
269 | gp_Vec& BiNormal, |
270 | gp_Vec& DBiNormal) |
271 | { |
272 | // return Standard_False; |
273 | gp_Pnt P, PG; |
274 | gp_Vec To,TG; |
275 | |
276 | |
277 | |
278 | // triedre de frenet sur la trajectoire |
279 | myCurve->D1(Param, P, To); |
280 | frenet->D1(Param,Tangent,DTangent,Normal,DNormal,BiNormal,DBiNormal); |
281 | |
282 | |
283 | // tolerance sur E |
284 | Standard_Integer Iter = 50; |
285 | |
286 | // fonction dont il faut trouver la racine : G(W)-Pl(U,V)=0 |
287 | InitX(Param); |
288 | GeomFill_PlanFunc E(P, Tangent, myGuide); |
289 | |
290 | // resolution |
291 | math_FunctionRoot Result(E, X(1), XTol(1), |
292 | Inf(1), Sup(1), Iter); |
293 | |
294 | if (Result.IsDone()) |
295 | { |
296 | Standard_Real Res = Result.Root(); |
297 | // R = Result.Root(); // solution |
298 | myTrimG->D1(Res, PG, TG); |
299 | gp_Vec n (P, PG), dn; // vecteur definissant la normale du triedre |
300 | Standard_Real Norm = n.Magnitude(); |
301 | if (Norm < 1.e-12) { |
302 | Norm = 1.0; |
303 | } |
304 | n /=Norm; |
305 | |
306 | |
307 | Normal = n; |
308 | BiNormal = Tangent.Crossed(Normal); |
309 | |
310 | // derivee premiere du triedre |
311 | Standard_Real dedx, dedt, dtg_dt; |
312 | E.Derivative(Res, dedx); |
313 | E.DEDT(Res, To, DTangent, dedt); |
314 | dtg_dt = -dedt/dedx; |
315 | |
316 | |
317 | /* Standard_Real h=1.e-7, e, etg, etc; |
318 | E.Value(Res, e); |
319 | E.Value(Res+h, etg); |
320 | if ( Abs( (etg-e)/h - dedx) > 1.e-4) { |
321 | cout << "err :" << (etg-e)/h - dedx << endl; |
322 | } |
323 | gp_Pnt pdbg; |
324 | gp_Vec td, nb, bnb; |
325 | myCurve->D0(Param+h, pdbg); |
326 | frenet->D0(Param+h,td, nb, bnb); |
327 | |
328 | GeomFill_PlanFunc Edeb(pdbg, td, myGuide); |
329 | Edeb.Value(Res, etc); |
330 | if ( Abs( (etc-e)/h - dedt) > 1.e-4) { |
331 | cout << "err :" << (etc-e)/h - dedt << endl; |
332 | } */ |
333 | |
334 | dn.SetLinearForm(dtg_dt, TG, -1, To); |
335 | |
336 | DNormal.SetLinearForm(-(n*dn), n, dn); |
337 | DNormal /= Norm; |
338 | DBiNormal.SetLinearForm(Tangent.Crossed(DNormal), |
339 | DTangent.Crossed(Normal)); |
340 | } |
341 | else {// Erreur... |
342 | #if DEB |
343 | cout << "D1 :"; |
344 | // plan ortho a la trajectoire |
345 | Handle(Geom_Plane) Plan = new (Geom_Plane)(P, Tangent); |
346 | TracePlan(Plan); |
347 | #endif |
348 | myStatus = GeomFill_PlaneNotIntersectGuide; |
349 | return Standard_False; |
350 | } |
351 | |
352 | return Standard_True; |
353 | } |
354 | |
355 | |
356 | //======================================================================= |
357 | //function : D2 |
358 | //purpose : calculation of trihedron and derivatives |
359 | //======================================================================= |
360 | Standard_Boolean GeomFill_GuideTrihedronPlan::D2(const Standard_Real Param, |
361 | gp_Vec& Tangent, |
362 | gp_Vec& DTangent, |
363 | gp_Vec& D2Tangent, |
364 | gp_Vec& Normal, |
365 | gp_Vec& DNormal, |
366 | gp_Vec& D2Normal, |
367 | gp_Vec& BiNormal, |
368 | gp_Vec& DBiNormal, |
369 | gp_Vec& D2BiNormal) |
370 | { |
371 | // gp_Pnt P, PG; |
372 | gp_Pnt P; |
373 | // gp_Vec To,DTo,TG,DTG; |
374 | gp_Vec To,DTo; |
375 | |
376 | myCurve->D2(Param, P, To, DTo); |
377 | |
378 | // triedre de Frenet sur la trajectoire |
379 | frenet->D2(Param,Tangent,DTangent,D2Tangent, |
380 | Normal,DNormal,D2Normal, |
381 | BiNormal,DBiNormal,D2BiNormal); |
382 | |
383 | /* |
384 | // plan ortho a Tangent pour trouver la pt Pprime sur le guide |
385 | Handle(Geom_Plane) Plan = new (Geom_Plane)(P, Tangent); |
386 | Handle(GeomAdaptor_HSurface) Pl= new(GeomAdaptor_HSurface)(Plan); |
387 | |
388 | |
389 | Standard_Integer Iter = 50; |
390 | // fonction dont il faut trouver la racine : G(W) - Pl(U,V)=0 |
391 | GeomFill_FunctionPipe E(Pl , myGuide); |
392 | InitX(Param); |
393 | |
394 | // resolution |
395 | math_FunctionSetRoot Result(E, X, XTol, |
396 | Inf, Sup, Iter); |
397 | if (Result.IsDone()) |
398 | { |
399 | math_Vector R(1,3); |
400 | R = Result.Root(); // solution |
401 | myTrimG->D2(R(1), PG, TG, DTG); |
402 | |
403 | gp_Vec n (P, PG); // vecteur definissant la normale du triedre |
404 | Standard_Real Norm = n.Magnitude(); |
405 | n /= Norm; |
406 | Normal = n.Normalized(); |
407 | BiNormal = Tangent.Crossed(Normal); |
408 | |
409 | |
410 | |
411 | // derivee premiere du triedre |
412 | Standard_Real dtp_dt; |
413 | dtp_dt = (To*Tangent - Norm*(n*DTangent))/(Tangent*TG); |
414 | gp_Vec dn, d2n; |
415 | dn.SetLinearForm(dtp_dt, TG, -1, To); |
416 | |
417 | DNormal.SetLinearForm(-(n*dn), n, dn); |
418 | DNormal /= Norm; |
419 | DBiNormal = Tangent.Crossed(DNormal) + DTangent.Crossed(Normal); |
420 | |
421 | // derivee seconde du triedre |
422 | Standard_Real d2tp_dt2; |
423 | d2tp_dt2 = (DTo*Tangent+To*DTangent - dn*DTangent-Norm*n*D2Tangent)/(TG*Tangent) |
424 | - (To*Tangent-Norm*n*DTangent) * (DTG*dtp_dt*Tangent+TG*DTangent) |
425 | / ((TG*Tangent)*(TG*Tangent)); |
426 | |
427 | |
428 | d2n.SetLinearForm(dtp_dt*dtp_dt, DTG, d2tp_dt2, TG, -DTo); |
429 | dn/=Norm; |
430 | d2n/=Norm; |
431 | |
432 | D2Normal.SetLinearForm(3*Pow(n*dn,2)- (dn.SquareMagnitude() + n*d2n), n, |
433 | -2*(n*dn), dn, |
434 | d2n); |
435 | |
436 | D2BiNormal.SetLinearForm(1, D2Tangent.Crossed(Normal), |
437 | 2, DTangent.Crossed(DNormal), |
438 | Tangent.Crossed(D2Normal)); |
439 | } |
440 | else {// Erreur... |
441 | #if DEB |
442 | cout << "D2 :"; |
443 | TracePlan(Plan); |
444 | #endif |
445 | myStatus = GeomFill_PlaneNotIntersectGuide; |
446 | return Standard_False; |
447 | } |
448 | */ |
449 | // return Standard_True; |
450 | return Standard_False; |
451 | } |
452 | |
453 | |
454 | //======================================================================= |
455 | //function : Copy |
456 | //purpose : |
457 | //======================================================================= |
458 | Handle(GeomFill_TrihedronLaw) GeomFill_GuideTrihedronPlan::Copy() const |
459 | { |
460 | Handle(GeomFill_GuideTrihedronPlan) copy = |
461 | new (GeomFill_GuideTrihedronPlan) (myGuide); |
462 | copy->SetCurve(myCurve); |
463 | return copy; |
464 | } |
465 | |
466 | //======================================================================= |
467 | //function : ErrorStatus |
468 | //purpose : |
469 | //======================================================================= |
470 | GeomFill_PipeError GeomFill_GuideTrihedronPlan::ErrorStatus() const |
471 | { |
472 | return myStatus; |
473 | } |
474 | |
475 | |
476 | //======================================================================= |
477 | //function : NbIntervals |
478 | //purpose : Version provisoire : Il faut tenir compte du guide |
479 | //======================================================================= |
480 | Standard_Integer GeomFill_GuideTrihedronPlan::NbIntervals(const GeomAbs_Shape S)const |
481 | { |
482 | Standard_Integer Nb; |
483 | GeomAbs_Shape tmpS; |
484 | switch (S) { |
485 | case GeomAbs_C0: tmpS = GeomAbs_C1; break; |
486 | case GeomAbs_C1: tmpS = GeomAbs_C2; break; |
487 | case GeomAbs_C2: tmpS = GeomAbs_C3; break; |
488 | default: tmpS = GeomAbs_CN; |
489 | } |
490 | |
491 | Nb = myCurve->NbIntervals(tmpS); |
492 | return Nb; |
493 | } |
494 | //====================================================================== |
495 | //function :Intervals |
496 | //purpose : |
497 | //======================================================================= |
498 | void GeomFill_GuideTrihedronPlan::Intervals(TColStd_Array1OfReal& TT, |
499 | const GeomAbs_Shape S) const |
500 | { |
501 | GeomAbs_Shape tmpS; |
502 | switch (S) { |
503 | case GeomAbs_C0: tmpS = GeomAbs_C1; break; |
504 | case GeomAbs_C1: tmpS = GeomAbs_C2; break; |
505 | case GeomAbs_C2: tmpS = GeomAbs_C3; break; |
506 | default: tmpS = GeomAbs_CN; |
507 | } |
508 | myCurve->Intervals(TT, tmpS); |
509 | } |
510 | |
511 | //====================================================================== |
512 | //function :SetInterval |
513 | //purpose : |
514 | //======================================================================= |
515 | void GeomFill_GuideTrihedronPlan::SetInterval(const Standard_Real First, |
516 | const Standard_Real Last) |
517 | { |
518 | myTrimmed = myCurve->Trim(First, Last, Precision::Confusion()); |
519 | } |
520 | |
521 | |
522 | //======================================================================= |
523 | //function : GetAverageLaw |
524 | //purpose : |
525 | //======================================================================= |
526 | void GeomFill_GuideTrihedronPlan::GetAverageLaw(gp_Vec& ATangent, |
527 | gp_Vec& ANormal, |
528 | gp_Vec& ABiNormal) |
529 | { |
530 | Standard_Integer ii; |
531 | Standard_Real t, Delta = (myCurve->LastParameter() - |
532 | myCurve->FirstParameter())/20.001; |
533 | |
534 | ATangent.SetCoord(0.,0.,0.); |
535 | ANormal.SetCoord(0.,0.,0.); |
536 | ABiNormal.SetCoord(0.,0.,0.); |
537 | gp_Vec T, N, B; |
538 | |
539 | for (ii=1, T; ii<=20; ii++) { |
540 | t = myCurve->FirstParameter() +(ii-1)*Delta; |
541 | D0(t, T, N, B); |
542 | ATangent +=T; |
543 | ANormal +=N; |
544 | ABiNormal+=B; |
545 | } |
546 | ATangent /= 20; |
547 | ANormal /= 20; |
548 | ABiNormal /= 20; |
549 | } |
550 | |
551 | //======================================================================= |
552 | //function : IsConstant |
553 | //purpose : |
554 | //======================================================================= |
555 | Standard_Boolean GeomFill_GuideTrihedronPlan::IsConstant() const |
556 | { |
557 | if ((myCurve->GetType() == GeomAbs_Line) && |
558 | (myGuide->GetType() == GeomAbs_Line)) { |
559 | Standard_Real Angle; |
560 | Angle = myCurve->Line().Angle(myGuide->Line()); |
561 | if ((Angle<1.e-12) || ((2*PI-Angle)<1.e-12) ) |
562 | return Standard_True; |
563 | } |
564 | |
565 | return Standard_False; |
566 | } |
567 | |
568 | //======================================================================= |
569 | //function : IsOnlyBy3dCurve |
570 | //purpose : |
571 | //======================================================================= |
572 | Standard_Boolean GeomFill_GuideTrihedronPlan::IsOnlyBy3dCurve() const |
573 | { |
574 | return Standard_False; |
575 | } |
576 | |
577 | //======================================================================= |
578 | //function : Origine |
579 | //purpose : Nothing!! |
580 | //======================================================================= |
581 | void GeomFill_GuideTrihedronPlan::Origine(const Standard_Real , |
582 | const Standard_Real ) |
583 | { |
584 | } |
585 | |
586 | //================================================================== |
587 | //Function : InitX |
588 | //Purpose : recherche par interpolation d'une valeur initiale |
589 | //================================================================== |
590 | void GeomFill_GuideTrihedronPlan::InitX(const Standard_Real Param) |
591 | { |
592 | |
593 | Standard_Integer Ideb = 1, Ifin = Pole->RowLength(), Idemi; |
594 | Standard_Real Valeur, t1, t2; |
595 | |
596 | |
597 | Valeur = Pole->Value(1, Ideb).X(); |
598 | if (Param == Valeur) { |
599 | Ifin = Ideb+1; |
600 | } |
601 | |
602 | Valeur = Pole->Value(1, Ifin).X(); |
603 | if (Param == Valeur) { |
604 | Ideb = Ifin-1; |
605 | } |
606 | |
607 | while ( Ideb+1 != Ifin) { |
608 | Idemi = (Ideb+Ifin)/2; |
609 | Valeur = Pole->Value(1, Idemi).X(); |
610 | if (Valeur < Param) { |
611 | Ideb = Idemi; |
612 | } |
613 | else { |
614 | if ( Valeur > Param) { Ifin = Idemi;} |
615 | else { |
616 | Ideb = Idemi; |
617 | Ifin = Ideb+1; |
618 | } |
619 | } |
620 | } |
621 | |
622 | t1 = Pole->Value(1,Ideb).X(); |
623 | t2 = Pole->Value(1,Ifin).X(); |
624 | Standard_Real diff = t2-t1; |
625 | if (diff > 1.e-7) { |
626 | Standard_Real b = (Param-t1) / diff, |
627 | a = (t2-Param) / diff; |
628 | |
629 | X(1) = Pole->Value(1,Ideb).Coord(2) * a |
630 | + Pole->Value(1,Ifin).Coord(2) * b; //param guide |
631 | } |
632 | else { |
633 | X(1) = (Pole->Value(1, Ideb).Coord(2) + |
634 | Pole->Value(1, Ifin).Coord(2)) / 2; |
635 | } |
636 | if (myGuide->IsPeriodic()) { |
637 | X(1) = ElCLib::InPeriod(X(1), myGuide->FirstParameter(), |
638 | myGuide->LastParameter()); |
639 | } |
640 | } |