projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / Adaptor3d / Adaptor3d_CurveOnSurface.cxx
CommitLineData
973c2be1 1// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 2//
973c2be1 3// This file is part of Open CASCADE Technology software library.
b311480e 4//
d5f74e42 5// This library is free software; you can redistribute it and/or modify it under
6// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 7// by the Free Software Foundation, with special exception defined in the file
8// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9// distribution for complete text of the license and disclaimer of any warranty.
b311480e 10//
973c2be1 11// Alternatively, this file may be used under the terms of Open CASCADE
12// commercial license or contractual agreement.
b311480e 13
7fd59977 14#define No_Standard_OutOfRange
15
7fd59977 16
42cf5bc1 17#include <Adaptor2d_HCurve2d.hxx>
18#include <Adaptor3d_CurveOnSurface.hxx>
19#include <Adaptor3d_HCurve.hxx>
54f7544d 20#include <Adaptor3d_HCurveOnSurface.hxx>
42cf5bc1 21#include <Adaptor3d_HSurface.hxx>
22#include <Adaptor3d_InterFunc.hxx>
23#include <ElCLib.hxx>
24#include <ElSLib.hxx>
25#include <Geom2d_BezierCurve.hxx>
26#include <Geom2d_BSplineCurve.hxx>
27#include <Geom_BezierCurve.hxx>
28#include <Geom_BSplineCurve.hxx>
29#include <Geom_BSplineSurface.hxx>
30#include <Geom_OffsetSurface.hxx>
31#include <Geom_SurfaceOfLinearExtrusion.hxx>
32#include <Geom_SurfaceOfRevolution.hxx>
7fd59977 33#include <gp_Ax22d.hxx>
42cf5bc1 34#include <gp_Circ.hxx>
7fd59977 35#include <gp_Circ2d.hxx>
42cf5bc1 36#include <gp_Elips.hxx>
7fd59977 37#include <gp_Elips2d.hxx>
42cf5bc1 38#include <gp_Hypr.hxx>
7fd59977 39#include <gp_Hypr2d.hxx>
42cf5bc1 40#include <gp_Lin.hxx>
41#include <gp_Lin2d.hxx>
42#include <gp_Parab.hxx>
7fd59977 43#include <gp_Parab2d.hxx>
42cf5bc1 44#include <gp_Pnt.hxx>
45#include <gp_Pnt2d.hxx>
46#include <gp_Vec.hxx>
47#include <gp_Vec2d.hxx>
48#include <math_FunctionRoots.hxx>
7fd59977 49#include <Precision.hxx>
54f7544d 50#include <Standard_Assert.hxx>
42cf5bc1 51#include <Standard_DomainError.hxx>
52#include <Standard_NoSuchObject.hxx>
53#include <Standard_NotImplemented.hxx>
54#include <Standard_OutOfRange.hxx>
7fd59977 55#include <TColgp_Array1OfPnt.hxx>
42cf5bc1 56#include <TColgp_Array1OfPnt2d.hxx>
7fd59977 57#include <TColStd_Array1OfInteger.hxx>
42cf5bc1 58#include <TColStd_Array1OfReal.hxx>
54f7544d 59#include <TColStd_HSequenceOfReal.hxx>
7fd59977 60
61static gp_Pnt to3d(const gp_Pln& Pl, const gp_Pnt2d& P)
62{
63 return ElSLib::Value(P.X(),P.Y(),Pl);
64}
65
66static gp_Vec to3d(const gp_Pln& Pl, const gp_Vec2d& V)
67{
68 gp_Vec Vx = Pl.XAxis().Direction();
69 gp_Vec Vy = Pl.YAxis().Direction();
70 Vx.Multiply(V.X());
71 Vy.Multiply(V.Y());
72 Vx.Add(Vy);
73 return Vx;
74}
75
76static gp_Ax2 to3d(const gp_Pln& Pl, const gp_Ax22d& A)
77{
78 gp_Pnt P = to3d(Pl,A.Location());
79 gp_Vec VX = to3d(Pl,A.XAxis().Direction());
80 gp_Vec VY = to3d(Pl,A.YAxis().Direction());
81 return gp_Ax2(P,VX.Crossed(VY),VX);
82}
83
84static gp_Circ to3d(const gp_Pln& Pl, const gp_Circ2d& C)
85{
86 return gp_Circ(to3d(Pl,C.Axis()),C.Radius());
87}
88
89static gp_Elips to3d(const gp_Pln& Pl, const gp_Elips2d& E)
90{
91 return gp_Elips(to3d(Pl,E.Axis()),E.MajorRadius(),E.MinorRadius());
92}
93
94static gp_Hypr to3d(const gp_Pln& Pl, const gp_Hypr2d& H)
95{
96 return gp_Hypr(to3d(Pl,H.Axis()),H.MajorRadius(),H.MinorRadius());
97}
98
99static gp_Parab to3d(const gp_Pln& Pl, const gp_Parab2d& P)
100{
101 return gp_Parab(to3d(Pl,P.Axis()),P.Focal());
102}
103
104static gp_Vec SetLinearForm(const gp_Vec2d DW, const gp_Vec2d D2W,const gp_Vec2d D3W,
105 const gp_Vec D1U, const gp_Vec D1V, const gp_Vec D2U,
106 const gp_Vec D2V, const gp_Vec D2UV, const gp_Vec D3U,
107 const gp_Vec D3V, const gp_Vec D3UUV,const gp_Vec D3UVV)
108{gp_Vec V31, V32, V33, V34,V3 ;
109 V31.SetLinearForm(DW.X(),D1U,
110 D2W.X()*DW.X(),D2U,
111 D2W.X()*DW.Y(),D2UV);
112 V31.SetLinearForm(D3W.Y(),D1V,
113 D2W.Y()*DW.X(),D2UV,
114 D2W.Y()*DW.Y(),D2V,
115 V31);
116 V32.SetLinearForm(DW.X()*DW.X()*DW.Y(),D3UUV,
117 DW.X()*DW.Y()*DW.Y(),D3UVV);
118 V32.SetLinearForm(D2W.X()*DW.Y()+DW.X()*D2W.Y(),D2UV,
119 DW.X()*DW.Y()*DW.Y(),D3UVV,
120 V32);
121 V33.SetLinearForm(2*D2W.X()*DW.X(),D2U,
122 DW.X()*DW.X()*DW.X(),D3U,
123 DW.X()*DW.X()*DW.Y(),D3UUV);
124
125 V34.SetLinearForm(2*D2W.Y()*DW.Y(),D2V,
126 DW.Y()*DW.Y()*DW.X(),D3UVV,
127 DW.Y()*DW.Y()*DW.Y(),D3V);
128 V3.SetLinearForm(1,V31,2,V32,1,V33,V34);
129 return V3;
130}
131
132//=======================================================================
133static void CompareBounds(gp_Pnt2d& P1,
134 gp_Pnt2d& P2)//SVV
135{
136 Standard_Real Lx = P1.X(),Ly = P1.Y();
137 Standard_Real Rx = P2.X(),Ry = P2.Y();
138
139 if (Lx > Rx) { P1.SetX(Rx); P2.SetX(Lx);}
140 if (Ly > Ry) { P1.SetY(Ry); P2.SetY(Ly);}
141}
142
143//=======================================================================
144//function :Hunt
145//purpose :
146//=======================================================================
147static void Hunt(const TColStd_Array1OfReal& Arr,
148 const Standard_Real Coord,
149 Standard_Integer& Iloc)
150{//Warning: Hunt is used to find number of knot which equals co-ordinate component,
151 // when co-ordinate component definitly equals a knot only.
152 Standard_Real Tol=Precision::PConfusion()/10;
153 Standard_Integer i=1;
82ac7cbb 154 while((i <= Arr.Upper()) && (Abs(Coord - Arr(i)) > Tol)){
7fd59977 155 i++;}
156
82ac7cbb 157 if(Abs(Coord - Arr(i)) < Tol)
7fd59977 158 Iloc = i;
159 else
82ac7cbb
S		 160 if(Abs(Coord - Arr(i)) > Tol)
161 Standard_NotImplemented::Raise("Adaptor3d_CurveOnSurface:Hunt");
7fd59977 162}
163
164//=======================================================================
165//function :ReverseParam
166//purpose :
167//=======================================================================
168
169static void ReverseParam(const Standard_Real In1,
170 const Standard_Real In2,
171 Standard_Real& Out1,
172 Standard_Real& Out2 )
173{
174
175 if(In1>In2) {Out1=In2;
176 Out2=In1;}
177 else {Out1=In1;
178 Out2=In2;}
179}
180//=======================================================================
181//function :ReverseParam
182//purpose :
183//=======================================================================
184
185static void ReverseParam(const Standard_Integer In1,
186 const Standard_Integer In2,
187 Standard_Integer& Out1,
188 Standard_Integer& Out2 )
189{
190 if(In1>In2) {Out1=In2;
191 Out2=In1;}
192 else {Out1=In1;
193 Out2=In2;}
194}
195
196//=======================================================================
197//function :FindBounds
198//purpose :
199//=======================================================================
200static void FindBounds(const TColStd_Array1OfReal& Arr,
201 const Standard_Real Coord,
202 const Standard_Real Der,
203 Standard_Integer& Bound1,
204 Standard_Integer& Bound2,
205 Standard_Boolean& DerNull)
206
207{
eb1ebea4 208 Standard_Integer N=0;
7fd59977 209 Standard_Real Tol=Precision::PConfusion()/10;
210 Hunt(Arr,Coord,N);
211 DerNull=Standard_False;
212
213 if(N==Bound1){ if(Abs(Der) > Tol) DerNull = Standard_False;
214 if(Abs(Der)<= Tol) DerNull = Standard_True;
215 Bound1=N;Bound2=N+1; return;
216 }
217 if(N==Bound2){ if( Abs(Der) > Tol ) DerNull = Standard_False;
218 if( Abs(Der)<= Tol ) DerNull = Standard_True;
219 Bound1=N-1;Bound2=N; return;
220 }
221 if((N!=Bound1)&&(N!=Bound2)) {
222 if(Abs(Der) > Tol ) {
223 if(Der>0) {Bound1=N;Bound2= N+1;}
224 else
225 if(Der<0){Bound1=N-1;Bound2=N;}
226 DerNull = Standard_False;
227 }
228 if(Abs(Der) <=Tol ) {
229 DerNull = Standard_True;
230 Bound1=N-1;
231 Bound2=N+1;
232 }
233 }
234}
235
236//=======================================================================
237//function :Locate1Coord
238//purpose : along BSpline curve
239//=======================================================================
240
241static void Locate1Coord(const Standard_Integer Index,
242 const gp_Pnt2d& UV,
243 const gp_Vec2d& DUV,
244 const Handle(Geom_BSplineCurve)& BSplC,
245 gp_Pnt2d& LeftBot, gp_Pnt2d& RightTop)
246{
d20d815b 247 Standard_Real Comp1=0, DComp1=0, cur, f = 0.0, l = 0.0;
7fd59977 248 Standard_Real Tol = Precision::PConfusion()/10;
249 Standard_Integer i = 1, Bnd1, Bnd2;
250 Standard_Boolean DIsNull= Standard_False;
251 TColStd_Array1OfReal Arr(1,BSplC->NbKnots()); BSplC->Knots(Arr);
252
253 if(Index==1) { Comp1=UV.X(); DComp1=DUV.X(); }
254 if(Index==2) { Comp1=UV.Y(); DComp1=DUV.Y(); }
255
256 Standard_Integer Lo = BSplC->FirstUKnotIndex(), Up = BSplC->LastUKnotIndex();
257
258 i = Lo;
259 while ( ( Abs(BSplC->Knot(i)-Comp1)>Tol )&& (i!=Up ) ) i++;
260 cur=BSplC->Knot(i);
261
262 if( Abs(Comp1-cur)<=Tol) {
263
264 Bnd1 = Lo; Bnd2 = Up;
265 FindBounds(Arr,cur,DComp1,Bnd1,Bnd2,DIsNull);
266 ReverseParam(Bnd1,Bnd2,Bnd1,Bnd2);
267
268 if(DIsNull==Standard_False){
269 if(Index==1) {LeftBot.SetX(BSplC->Knot(Bnd1));
270 RightTop.SetX(BSplC->Knot(Bnd2));}
271 else
272 if(Index==2){ LeftBot.SetY(BSplC->Knot(Bnd1));
273 RightTop.SetY(BSplC->Knot(Bnd2)); }
274 }
275 else
276 if(DIsNull==Standard_True){
277 if( Abs( Comp1-(f=BSplC->Knot(Lo))) <= Tol)
278 {
279 if(Index==1) { LeftBot.SetX(BSplC->Knot(Lo));
280 RightTop.SetX(BSplC->Knot(Lo+1));}
281 else if(Index==2) { LeftBot.SetY(BSplC->Knot(Lo));
282 RightTop.SetY(BSplC->Knot(Lo+1));}
283 } else
284 if( Abs( Comp1-(l=BSplC->Knot(Up))) <= Tol)
285 {
286 if(Index==1) { LeftBot.SetX(BSplC->Knot(Up-1));
287 RightTop.SetX(BSplC->Knot(Up));}
288 else if(Index==2) {LeftBot.SetY(BSplC->Knot(Up-1));
289 RightTop.SetY(BSplC->Knot(Up));}
290 }else
291 if(Index==1) { LeftBot.SetX(BSplC->Knot(Bnd1));
292 RightTop.SetX(BSplC->Knot(Bnd2));}
293 else if(Index==2) {LeftBot.SetY(BSplC->Knot(Bnd1));
294 RightTop.SetY(BSplC->Knot(Bnd2));}
295 }
296 }
297 else//*********if Coord != Knot
298 {
299 i=Lo;
300 while (i < Up) {
301 //if((f=BSplC->Knot(i))<Comp1 && (l=BSplC->Knot(i+1))>Comp1) break;
302 //skl 28.03.2002 for OCC233
303 f=BSplC->Knot(i);
304 l=BSplC->Knot(i+1);
305 if(f<Comp1 && l>Comp1) break;
306 i++;
307 }
308 ReverseParam(f,l,f,l);
309
310 if(i!=Up) {
311 if(Abs(DComp1)<Tol)
312 { if(Index==1) {LeftBot.SetX(f); RightTop.SetX(l);}else
313 if(Index==2) {LeftBot.SetY(f); RightTop.SetY(l); }
314 }else
315 if(Abs(DComp1)>Tol)
316 {
317 if(Index==1) {
318 if(DComp1>0) {LeftBot.SetX(Comp1); RightTop.SetX(l);} else
319 if(DComp1<0) {LeftBot.SetX(f); RightTop.SetX(Comp1);}
320 }
321 else
322 if(Index==2) {
323 if(DComp1>0) {LeftBot.SetY(Comp1); RightTop.SetY(l);} else
324 if(DComp1<0) {LeftBot.SetY(f); RightTop.SetY(Comp1);};
325 }
326 }
327 }else
328 if(i==Up) {
329 if(Index==1) {LeftBot.SetX(Comp1); RightTop.SetX(BSplC->Knot(i));}else
330 if(Index==2) {LeftBot.SetY(Comp1); RightTop.SetY(BSplC->Knot(i)); }
331 }
332 }
333}
334
335
336//=======================================================================
337//function :Locate1Coord
338//purpose :
339//=======================================================================
340
341static void Locate1Coord(const Standard_Integer Index,
1d47d8d0 342 const gp_Pnt2d& UV,
343 const gp_Vec2d& DUV,
344 const Handle(Geom_BSplineSurface)& BSplS,
345 Standard_Boolean& DIsNull,
346 gp_Pnt2d& LeftBot,
347 gp_Pnt2d& RightTop)
7fd59977 348{
349 Standard_Real Comp1=0,DComp1=0;
350 Standard_Real Tol = Precision::PConfusion()/10;
1d47d8d0 351 Standard_Integer i=1, Up=0, Up1, Up2, Down=0, Down1, Down2;
352 Standard_Real cur = 0.;
7fd59977 353
354 DIsNull= Standard_False;
355
356 Up1 = BSplS->LastUKnotIndex();
357 Down1 = BSplS->FirstUKnotIndex();
358 Up2 = BSplS->LastVKnotIndex();
359 Down2 = BSplS->FirstVKnotIndex();
360
1d47d8d0 361 if(Index==1)
362 {
363 i = Down1;
364 Comp1 = UV.X();
365 DComp1= DUV.X();
366 Up=Up1;
367 Down=Down1;
368
369 while ( ( Abs(BSplS->UKnot(i)-Comp1)>Tol )&&(i!=Up1 ) )
370 {
371 i++;
372 }
373
374 cur = BSplS->UKnot(i);
375 }
376 else if(Index==2)
377 {
378 i = Down2;
379 Comp1 = UV.Y();
380 DComp1=DUV.Y();
381 Up=Up2;
382 Down=Down2;
383
384 while ( ( Abs(BSplS->VKnot(i)-Comp1)>Tol )&&(i!=Up2 ) )
385 {
386 i++;
387 }
388
389 cur = BSplS->VKnot(i);
390 }
7fd59977 391
392 if( Abs(Comp1-cur)<=Tol )
1d47d8d0 393 {
394 Standard_Integer Bnd1 = Down, Bnd2 = Up;
395 if(Index==1)
396 {
397 TColStd_Array1OfReal Arr1(1,BSplS->NbUKnots());
398 BSplS->UKnots(Arr1); // Up1=Arr1.Upper(); Down1=Arr1.Lower();
399 FindBounds(Arr1,cur,DUV.X(),Bnd1,Bnd2,DIsNull);
400 }
401 else if(Index==2)
402 {
403 TColStd_Array1OfReal Arr2(1,BSplS->NbVKnots());
404 BSplS->VKnots(Arr2); // Up2=Arr2.Upper(); Down2=Arr2.Lower();
405 FindBounds(Arr2,cur,DUV.Y(),Bnd1,Bnd2,DIsNull);
406 }
407
408 ReverseParam(Bnd1,Bnd2,Bnd1,Bnd2);
409
410 if(DIsNull==Standard_False)
411 {
412 if(Index==1)
413 {
414 LeftBot.SetX(BSplS->UKnot(Bnd1));
415 RightTop.SetX(BSplS->UKnot(Bnd2));
7fd59977 416 }
1d47d8d0 417 else if(Index==2)
418 {
419 LeftBot.SetY(BSplS->VKnot(Bnd1));
420 RightTop.SetY(BSplS->VKnot(Bnd2));
7fd59977 421 }
1d47d8d0 422 }
423 }
7fd59977 424 else//*********if Coord != Knot
1d47d8d0 425 {
426 if( (Index==1)&&(Comp1 < BSplS->UKnot(Down)) )
427 {
428 LeftBot.SetX(BSplS->UKnot(Down));
429 RightTop.SetX( BSplS->UKnot(Down + 1) );
430 return;
431 }
432 else if( (Index==2)&&(Comp1 < BSplS->VKnot(Down)) )
433 {
434 LeftBot.SetY(BSplS->VKnot(Down));
435 RightTop.SetY( BSplS->VKnot(Down + 1) );
436 return;
437 }
438 else if( (Index==1)&&(Comp1 > BSplS->UKnot(Up)) )
439 {
440 RightTop.SetX(BSplS->UKnot(Up - 1));
441 LeftBot.SetX( BSplS->UKnot(Up) );
442 return;
443 }
444 else if( (Index==2)&&(Comp1 > BSplS->VKnot(Up)) )
445 {
446 RightTop.SetY(BSplS->VKnot(Up - 1));
447 LeftBot.SetY( BSplS->VKnot(Up) );
448 return;
449 }
450 else
7fd59977 451 {
1d47d8d0 452 Standard_Real f = 0., l = 1.;
453 if (Index==1)
454 {
455 f=BSplS->UKnot(Down);
456 l=BSplS->UKnot(Up);
457 }
458 else if (Index == 2)
459 {
460 f=BSplS->VKnot(Down);
461 l=BSplS->VKnot(Up);
462 }
463
464 i = Down;
465 if ((!(Comp1 < f))&&(!(Comp1 > l)))
466 {
467 if (Index==1)
468 {
469 while (!(((f=BSplS->UKnot(i)) < Comp1)&&((l=BSplS->UKnot(i+1)) > Comp1)) && (i<Up))
470 {
471 i++;
472 }
473 }
474 else if (Index==2)
475 {
476 while (!(((f=BSplS->VKnot(i)) < Comp1)&&((l=BSplS->VKnot(i+1)) > Comp1)) && (i<Up))
477 {
478 i++;
479 }
480 }
481 }
7fd59977 482 else
1d47d8d0 483 ReverseParam(f,l,f,l);
484
485 if(i!=Up)
486 {
487 if(Abs(DComp1)>Tol)
488 {
489 if(Index==1)
490 {
491 if(DComp1>0)
492 {
493 LeftBot.SetX(Comp1);
494 RightTop.SetX(l);
495 }
496 else if(DComp1<0)
497 {
498 LeftBot.SetX(f);
499 RightTop.SetX(Comp1);
500 }
501 }
502 else if(Index==2)
503 {
504 if(DComp1>0)
505 {
506 LeftBot.SetY(Comp1);
507 RightTop.SetY(l);
508 }
509 else if(DComp1<0)
510 {
511 LeftBot.SetY(f);
512 RightTop.SetY(Comp1);
513 }
514 }
515 }
516 else
517 {
518 if(Abs(DComp1)<Tol)
519 {
520 if(Index==1)
521 {
522 LeftBot.SetX(f);
523 RightTop.SetX(l);
524 }
525 else if(Index==2)
526 {
527 LeftBot.SetY(f);
528 RightTop.SetY(l);
529 }
530 }
531 }
532 }
533 else if(i==Up)
534 {
535 if(Index==1)
536 {
537 LeftBot.SetX(Comp1);
538 RightTop.SetX(BSplS->UKnot(i));
539 }
540 else if(Index==2)
541 {
542 LeftBot.SetY(Comp1);
543 RightTop.SetY(BSplS->VKnot(i));
544 }
545 }
7fd59977 546 }
1d47d8d0 547 }
7fd59977 548}
549//=======================================================================
550//function :Locate2Coord
551//purpose : along non-BSpline curve
552//=======================================================================
553
554
555static void Locate2Coord(const Standard_Integer Index,
556 const gp_Pnt2d& UV, const gp_Vec2d& DUV,
557 const Standard_Real I1,
558 const Standard_Real I2,
559 gp_Pnt2d& LeftBot, gp_Pnt2d& RightTop)
560{
561 Standard_Real Tol=Precision::PConfusion()/10;
562 Standard_Real Comp1=0,DComp1=0;
7fd59977 563 if(Index==1) { Comp1=UV.X();
564 DComp1=DUV.X();}
565 else
566 if(Index==2) {Comp1=UV.Y();
567 DComp1=DUV.Y();}
568
569 if((Comp1!=I1)&&(Comp1!=I2))
570 { if(Abs(DComp1) > Tol)
571 { if(DComp1 < 0)
572 { if(Index==1) { LeftBot.SetX(I1);
573 RightTop.SetX(Comp1);}
574 if(Index==2) { LeftBot.SetY(I1);
575 RightTop.SetY(Comp1);}
576 }
577 else
578 if(DComp1 > 0)
579 { if(Index==1) { LeftBot.SetX(Comp1);
580 RightTop.SetX(I2);}
581 if(Index==2) { LeftBot.SetY(Comp1);
582 RightTop.SetY(I2);}
583 }
584 else { if(Index==1) { LeftBot.SetX(I1);
585 RightTop.SetX(I2);}
586 if(Index==2) { LeftBot.SetY(I1);
587 RightTop.SetY(I2);}
588 }
7fd59977 589 }
590 else
96a95605 591 if(Abs(DComp1)<=Tol) {
7fd59977 592 if(Index==1) { LeftBot.SetX(I1) ;
593 RightTop.SetX(I2);}
594 if(Index==2) { LeftBot.SetY(I1) ;
595 RightTop.SetY(I2);}
596 }
597 }else
598 if(Abs(Comp1-I1)<Tol)
599 { if(Index==1) { LeftBot.SetX(I1) ;
600 RightTop.SetX(I2);}
601 if(Index==2) { LeftBot.SetY(I1) ;
602 RightTop.SetY(I2);}
603 }
604 else
605 if(Abs(Comp1-I2)<Tol)
606 { if(Index==1) { LeftBot.SetX(I1);
607 RightTop.SetX(I2);}
608 if(Index==2) { LeftBot.SetY(I1);
609 RightTop.SetY(I2);}
610 }
611}
612
613//=======================================================================
614//function :Locate2Coord
615//purpose :
616//=======================================================================
617
618static void Locate2Coord(const Standard_Integer Index,
619 const gp_Pnt2d& UV, const gp_Vec2d& DUV,
620 const Handle(Geom_BSplineSurface)& BSplS,
621 const TColStd_Array1OfReal& Arr,
622 gp_Pnt2d& LeftBot, gp_Pnt2d& RightTop)
623{
d20d815b 624 Standard_Real Comp=0,DComp=0,Tmp1=0.0,Tmp2=0.0;
7fd59977 625 Standard_Real Tol=Precision::PConfusion()/10;
eb1ebea4 626 Standard_Integer N=0, NUp=0, NLo=0;
7fd59977 627 if(Index==1)
628 { Comp=UV.X();
629 DComp=DUV.Y();
630 NUp = BSplS->LastUKnotIndex();
631 NLo = BSplS->FirstUKnotIndex();
632 }
633 if(Index==2)
634 { Comp=UV.Y();
635 DComp=DUV.X();
636 NUp = BSplS->LastVKnotIndex();
637 NLo = BSplS->FirstVKnotIndex();
638 }
639
640 if((DComp > 0)&&(Abs(DComp)>Tol)) {
641 Hunt(Arr,Comp,N);
642 if (N >= NUp){
643 //limit case: Hunt() cought upper knot. Take the last span.
644 N = NUp - 1;
645 }
646 if(Index==1) { Tmp1=BSplS->UKnot(N);
647 Tmp2=BSplS->UKnot(N+1);}
648 else
649 if(Index==2) { Tmp1=BSplS->VKnot(N);
650 Tmp2=BSplS->VKnot(N+1);}
651
652 ReverseParam(Tmp1,Tmp2,Tmp1,Tmp2);
653
654 if(Index==1) { LeftBot.SetX(Tmp1);
655 RightTop.SetX(Tmp2);}
656 else
657 if(Index==2) { LeftBot.SetY(Tmp1);
658 RightTop.SetY(Tmp2);}
659 }
660 else
661 if((DComp < 0)&&(Abs(DComp)>Tol)){
662 Hunt(Arr,Comp,N);
663 if (N <= NLo) {
664 //limit case: Hunt() cought lower knot. Take the first span.
665 N = NLo + 1;
666 }
667 if(Index==1) { Tmp1=BSplS->UKnot(N-1);
668 Tmp2=BSplS->UKnot(N);}
669 else
670 if(Index==2) { Tmp1=BSplS->VKnot(N-1);
671 Tmp2=BSplS->VKnot(N);}
672
673 ReverseParam(Tmp1,Tmp2,Tmp1,Tmp2);
674
675 if(Index==1) { LeftBot.SetX(Tmp1);
676 RightTop.SetX(Tmp2);}
677 else
678 if(Index==2) { LeftBot.SetY(Tmp1);
679 RightTop.SetY(Tmp2);}
680 }
681}
682
683
684
685//=======================================================================
686//function : Adaptor3d_CurveOnSurface
687//purpose :
688//=======================================================================
689
690Adaptor3d_CurveOnSurface::Adaptor3d_CurveOnSurface()
691 : myType(GeomAbs_OtherCurve), myIntCont(GeomAbs_CN)
692{}
693
694//=======================================================================
695//function : Adaptor3d_CurveOnSurface
696//purpose :
697//=======================================================================
698
699Adaptor3d_CurveOnSurface::Adaptor3d_CurveOnSurface
700(const Handle(Adaptor3d_HSurface)& S)
701 : myType(GeomAbs_OtherCurve), myIntCont(GeomAbs_CN)
702{
703 Load(S);
704}
705
706//=======================================================================
707//function : Adaptor3d_CurveOnSurface
708//purpose :
709//=======================================================================
710
711Adaptor3d_CurveOnSurface::Adaptor3d_CurveOnSurface
712(const Handle(Adaptor2d_HCurve2d)& C,
713 const Handle(Adaptor3d_HSurface)& S)
714 : myType(GeomAbs_OtherCurve), myIntCont(GeomAbs_CN)
715{
716 Load(S);
717 Load(C);
718}
719
720//=======================================================================
721//function : Load
722//purpose :
723//=======================================================================
724
725void Adaptor3d_CurveOnSurface::Load(const Handle(Adaptor3d_HSurface)& S)
726{
727 mySurface = S;
728 if (!myCurve.IsNull()) EvalKPart();
729}
730
731//=======================================================================
732//function : Load
733//purpose :
734//=======================================================================
735
736void Adaptor3d_CurveOnSurface::Load(const Handle(Adaptor2d_HCurve2d)& C)
737{
738 myCurve = C;
739 if (!mySurface.IsNull())
740 {
741 EvalKPart();
742 GeomAbs_SurfaceType SType ;
743 SType = mySurface->GetType();
744 if( SType == GeomAbs_BSplineSurface)
745 EvalFirstLastSurf();
746 if( SType == GeomAbs_SurfaceOfExtrusion)
747 EvalFirstLastSurf();
748 if( SType == GeomAbs_SurfaceOfRevolution)
749 EvalFirstLastSurf();
750 if( SType == GeomAbs_OffsetSurface) {
751 SType = mySurface->BasisSurface()->GetType();
752 if( SType == GeomAbs_SurfaceOfRevolution ||
753 SType == GeomAbs_SurfaceOfExtrusion ||
754 SType == GeomAbs_BSplineSurface )
755 EvalFirstLastSurf();
756 }
757 }
758}
759
760//=======================================================================
543a9964 761//function : Load
762//purpose :
763//=======================================================================
764
765void Adaptor3d_CurveOnSurface::Load (const Handle(Adaptor2d_HCurve2d)& C,
766 const Handle(Adaptor3d_HSurface)& S)
767{
768 Load (C);
769 Load (S);
770}
771
772//=======================================================================
7fd59977 773//function : FirstParameter
774//purpose :
775//=======================================================================
776
777Standard_Real Adaptor3d_CurveOnSurface::FirstParameter() const
778{
779 return myCurve->FirstParameter();
780}
781
782//=======================================================================
783//function : LastParameter
784//purpose :
785//=======================================================================
786
787Standard_Real Adaptor3d_CurveOnSurface::LastParameter() const
788{
789 return myCurve->LastParameter();
790}
791
792//=======================================================================
793//function : Continuity
794//purpose :
795//=======================================================================
796
797GeomAbs_Shape Adaptor3d_CurveOnSurface::Continuity() const
798{
799 GeomAbs_Shape ContC = myCurve->Continuity();
800 GeomAbs_Shape ContSu = mySurface->UContinuity();
801 if ( ContSu < ContC) ContC = ContSu;
802 GeomAbs_Shape ContSv = mySurface->VContinuity();
803 if ( ContSv < ContC) ContC = ContSv;
804
805 return ContC;
806}
807
54f7544d 808// Auxiliary: adds roots of equation to sorted sequence of parameters
809// along curve, keeping it sorted and avoiding repetitions (within tolerance Tol)
810static void AddIntervals (const Handle(TColStd_HSequenceOfReal)& theParameters,
811 const math_FunctionRoots& theRoots, Standard_Real theTol)
812{
813 if (! theRoots.IsDone() || theRoots.IsAllNull())
814 return;
815
816 Standard_Integer nsol = theRoots.NbSolutions();
817 for (Standard_Integer i = 1; i <= nsol; i++)
818 {
819 Standard_Real param = theRoots.Value(i);
820 if (param - theParameters->Value(1) < theTol) // skip param if equal to or less than theParameters(1)
821 continue;
822 for (Standard_Integer j=2; j <= theParameters->Length(); ++j)
823 {
824 Standard_Real aDelta = theParameters->Value(j) - param;
825 if (aDelta > theTol)
826 {
827 theParameters->InsertBefore (j, param);
828 break;
829 }
830 else if (aDelta >= -theTol) // param == theParameters(j) within Tol
831 break;
832 }
833 }
834}
835
7fd59977 836//=======================================================================
837//function : NbIntervals
838//purpose :
839//=======================================================================
840
31b1749c 841Standard_Integer Adaptor3d_CurveOnSurface::NbIntervals (const GeomAbs_Shape S) const
7fd59977 842{
843 if(S == myIntCont && !myIntervals.IsNull())
844 return myIntervals->Length()-1;
845
54f7544d 846 Standard_Integer nu,nv,nc;
7fd59977 847 nu=mySurface->NbUIntervals(S);
848 nv=mySurface->NbVIntervals(S);
54f7544d 849
7fd59977 850 TColStd_Array1OfReal TabU(1,nu+1);
851 TColStd_Array1OfReal TabV(1,nv+1);
852 Standard_Integer NbSample = 20;
853 Standard_Real U,V,Tdeb,Tfin;
854 Tdeb=myCurve->FirstParameter();
855 Tfin=myCurve->LastParameter();
54f7544d 856
7fd59977 857 nc=myCurve->NbIntervals(S);
858 TColStd_Array1OfReal TabC(1,nc+1);
859 myCurve->Intervals(TabC,S);
54f7544d 860
7fd59977 861 Standard_Real Tol= Precision::PConfusion()/10;
54f7544d 862
863 // sorted sequence of parameters defining continuity intervals;
864 // started with own intervals of curve and completed by
865 // additional points coming from surface discontinuities
31b1749c 866 Handle(TColStd_HSequenceOfReal) aIntervals = new TColStd_HSequenceOfReal;
54f7544d 867 for (Standard_Integer i = 1; i <= nc + 1; i++)
868 {
31b1749c 869 aIntervals->Append(TabC(i));
54f7544d 870 }
7fd59977 871
54f7544d 872 if (nu>1)
873 {
874 mySurface->UIntervals(TabU,S);
875 for(Standard_Integer iu = 2;iu <= nu; iu++)
876 {
877 U = TabU.Value(iu);
878 Adaptor3d_InterFunc Func(myCurve,U,1);
879 math_FunctionRoots Resol(Func,Tdeb,Tfin,NbSample,Tol,Tol,Tol,0.);
31b1749c 880 AddIntervals (aIntervals, Resol, Tol);
54f7544d 881 }
7fd59977 882 }
54f7544d 883 if (nv>1)
884 {
885 mySurface->VIntervals(TabV,S);
886 for(Standard_Integer iv = 2;iv <= nv; iv++)
887 {
888 V = TabV.Value(iv);
889 Adaptor3d_InterFunc Func(myCurve,V,2);
890 math_FunctionRoots Resol(Func,Tdeb,Tfin,NbSample,Tol,Tol,Tol,0.);
31b1749c 891 AddIntervals (aIntervals, Resol, Tol);
54f7544d 892 }
7fd59977 893 }
894
54f7544d 895 // for case intervals==1 and first point == last point SequenceOfReal
7fd59977 896 // contains only one value, therefore it is necessary to add second
31b1749c 897 // value into aIntervals which will be equal first value.
898 if (aIntervals->Length() == 1)
899 aIntervals->Append (aIntervals->Value(1));
7fd59977 900
31b1749c 901 const_cast<Adaptor3d_CurveOnSurface*>(this)->myIntervals = aIntervals;
902 const_cast<Adaptor3d_CurveOnSurface*>(this)->myIntCont = S;
54f7544d 903 return myIntervals->Length() - 1;
7fd59977 904}
905
906//=======================================================================
907//function : Intervals
908//purpose :
909//=======================================================================
910
911void Adaptor3d_CurveOnSurface::Intervals(TColStd_Array1OfReal& T,
31b1749c 912 const GeomAbs_Shape S) const
7fd59977 913{
914 NbIntervals(S);
54f7544d 915 Standard_ASSERT_RAISE (T.Length() == myIntervals->Length(), "Error: Wrong size of array buffer in call to Adaptor3d_CurveOnSurface::Intervals");
7fd59977 916 for(Standard_Integer i=1; i<=myIntervals->Length(); i++) {
917 T(i) = myIntervals->Value(i);
918 }
7fd59977 919}
920
921//=======================================================================
922//function : Trim
923//purpose :
924//=======================================================================
925
926Handle(Adaptor3d_HCurve) Adaptor3d_CurveOnSurface::Trim
927(const Standard_Real First,
928 const Standard_Real Last,
929 const Standard_Real Tol) const
930{
931 Handle(Adaptor3d_HCurveOnSurface) HCS = new Adaptor3d_HCurveOnSurface();
932 HCS->ChangeCurve().Load(mySurface);
933 HCS->ChangeCurve().Load(myCurve->Trim(First,Last,Tol));
934 return HCS;
935}
936
937//=======================================================================
938//function : IsClosed
939//purpose :
940//=======================================================================
941
942Standard_Boolean Adaptor3d_CurveOnSurface::IsClosed() const
943{
944 return myCurve->IsClosed();
945}
946
947//=======================================================================
948//function : IsPeriodic
949//purpose :
950//=======================================================================
951
952Standard_Boolean Adaptor3d_CurveOnSurface::IsPeriodic() const
953{
954 return myCurve->IsPeriodic();
955}
956
957//=======================================================================
958//function : Period
959//purpose :
960//=======================================================================
961
962Standard_Real Adaptor3d_CurveOnSurface::Period() const
963{
964 return myCurve->Period();
965}
966
967//=======================================================================
968//function : Value
969//purpose :
970//=======================================================================
971
972gp_Pnt Adaptor3d_CurveOnSurface::Value(const Standard_Real U ) const
973{
974 gp_Pnt P;
975 gp_Pnt2d Puv;
976
977 if (myType == GeomAbs_Line ) P = ElCLib::Value(U,myLin );
978 else if (myType == GeomAbs_Circle) P = ElCLib::Value(U,myCirc);
979 else {
980 myCurve->D0(U,Puv);
981 mySurface->D0(Puv.X(),Puv.Y(),P);
982 }
983
984 return P;
985}
986
987//=======================================================================
988//function : D0
989//purpose :
990//=======================================================================
991
992void Adaptor3d_CurveOnSurface::D0(const Standard_Real U ,
993 gp_Pnt& P) const
994{
995 gp_Pnt2d Puv;
996
997 if (myType == GeomAbs_Line ) P = ElCLib::Value(U,myLin );
998 else if (myType == GeomAbs_Circle) P = ElCLib::Value(U,myCirc);
999 else {
1000 myCurve->D0(U,Puv);
1001 mySurface->D0(Puv.X(),Puv.Y(),P);
1002 }
1003
1004}
1005
1006
1007//=======================================================================
1008//function : D1
1009//purpose :
1010//=======================================================================
1011
1012void Adaptor3d_CurveOnSurface::D1(const Standard_Real U ,
1013 gp_Pnt& P,
1014 gp_Vec& V) const
1015{
1016 gp_Pnt2d Puv;
1017 gp_Vec2d Duv;
1018 gp_Vec D1U,D1V;
1019
1020 Standard_Real FP = myCurve->FirstParameter();
1021 Standard_Real LP = myCurve->LastParameter();
1022
1023 Standard_Real Tol= Precision::PConfusion()/10;
1024 if( ( Abs(U-FP)<Tol)&&(!myFirstSurf.IsNull()) )
1025 {
1026 myCurve->D1(U,Puv,Duv);
1027 myFirstSurf->D1(Puv.X(),Puv.Y(),P,D1U,D1V);
1028 V.SetLinearForm(Duv.X(),D1U,Duv.Y(),D1V);
1029 }
1030 else
1031 if( (Abs(U-LP)<Tol)&&(!myLastSurf.IsNull()) )
1032 {
1033 myCurve->D1(U,Puv,Duv);
1034 myLastSurf->D1(Puv.X(),Puv.Y(),P,D1U,D1V);
1035 V.SetLinearForm(Duv.X(),D1U,Duv.Y(),D1V);
1036 }
1037 else
1038 if (myType == GeomAbs_Line ) ElCLib::D1(U,myLin ,P,V);
1039 else if (myType == GeomAbs_Circle) ElCLib::D1(U,myCirc,P,V);
1040 else {
1041 myCurve->D1(U,Puv,Duv);
1042 mySurface->D1(Puv.X(),Puv.Y(),P,D1U,D1V);
1043 V.SetLinearForm(Duv.X(),D1U,Duv.Y(),D1V);
1044 }
1045}
1046//=======================================================================
1047//function : D2
1048//purpose :
1049//=======================================================================
1050
1051void Adaptor3d_CurveOnSurface::D2(const Standard_Real U,
1052 gp_Pnt& P,
1053 gp_Vec& V1,
1054 gp_Vec& V2) const
1055{
1056 gp_Pnt2d UV;
1057 gp_Vec2d DW,D2W;
1058 gp_Vec D1U,D1V,D2U,D2V,D2UV;
1059
1060 Standard_Real FP = myCurve->FirstParameter();
1061 Standard_Real LP = myCurve->LastParameter();
1062
1063 Standard_Real Tol= Precision::PConfusion()/10;
1064 if( (Abs(U-FP)<Tol)&&(!myFirstSurf.IsNull()) )
1065 {
1066 myCurve->D2(U,UV,DW,D2W);
1067 myFirstSurf->D2(UV.X(),UV.Y(),P,D1U,D1V,D2U,D2V,D2UV);
1068
1069 V1.SetLinearForm(DW.X(),D1U,DW.Y(),D1V);
1070 V2.SetLinearForm(D2W.X(), D1U, D2W.Y(), D1V, 2.*DW.X()*DW.Y(),D2UV);
1071 V2.SetLinearForm(DW.X()*DW.X(), D2U, DW.Y()*DW.Y(), D2V, V2);
1072 }
1073 else
1074 if( (Abs(U-LP)<Tol)&&(!myLastSurf.IsNull()) )
1075 {
1076 myCurve->D2(U,UV,DW,D2W);
1077 myLastSurf->D2(UV.X(),UV.Y(),P,D1U,D1V,D2U,D2V,D2UV);
1078
1079 V1.SetLinearForm(DW.X(),D1U,DW.Y(),D1V);
1080 V2.SetLinearForm(D2W.X(), D1U, D2W.Y(), D1V, 2.*DW.X()*DW.Y(),D2UV);
1081 V2.SetLinearForm(DW.X()*DW.X(), D2U, DW.Y()*DW.Y(), D2V, V2);
1082 }
1083 else
1084 if (myType == GeomAbs_Line ) {
1085 ElCLib::D1(U,myLin,P,V1);
1086 V2.SetCoord(0.,0.,0.);
1087 }
1088 else if (myType == GeomAbs_Circle) ElCLib::D2(U,myCirc,P,V1,V2);
1089 else {
1090 myCurve->D2(U,UV,DW,D2W);
1091 mySurface->D2(UV.X(),UV.Y(),P,D1U,D1V,D2U,D2V,D2UV);
1092
1093 V1.SetLinearForm(DW.X(),D1U,DW.Y(),D1V);
1094 V2.SetLinearForm(D2W.X(), D1U, D2W.Y(), D1V, 2.*DW.X()*DW.Y(),D2UV);
1095 V2.SetLinearForm(DW.X()*DW.X(), D2U, DW.Y()*DW.Y(), D2V, V2);
1096 }
1097}
1098
1099//=======================================================================
1100//function : D3
1101//purpose :
1102//=======================================================================
1103
1104void Adaptor3d_CurveOnSurface::D3
1105 (const Standard_Real U,
1106 gp_Pnt& P,
1107 gp_Vec& V1,
1108 gp_Vec& V2,
1109 gp_Vec& V3) const
1110{
1111
1112 Standard_Real Tol= Precision::PConfusion()/10;
1113 gp_Pnt2d UV;
1114 gp_Vec2d DW,D2W,D3W;
1115 gp_Vec D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV;
1116
1117 Standard_Real FP = myCurve->FirstParameter();
1118 Standard_Real LP = myCurve->LastParameter();
1119
1120 if( (Abs(U-FP)<Tol)&&(!myFirstSurf.IsNull()) )
1121 { myCurve->D3(U,UV,DW,D2W,D3W);
1122 myFirstSurf->D3(UV.X(),UV.Y(),P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
1123 V1.SetLinearForm(DW.X(),D1U,DW.Y(),D1V);
1124 V2.SetLinearForm(D2W.X(), D1U, D2W.Y(), D1V, 2.*DW.X()*DW.Y(),D2UV);
1125 V2.SetLinearForm(DW.X()*DW.X(), D2U, DW.Y()*DW.Y(), D2V, V2);
1126 V3=SetLinearForm( DW, D2W, D3W, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
1127 }else
1128
1129 if( (Abs(U-LP)<Tol)&&(!myLastSurf.IsNull()) )
1130 { myCurve->D3(U,UV,DW,D2W,D3W);
1131 myLastSurf->D3(UV.X(),UV.Y(),P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
1132 V1.SetLinearForm(DW.X(),D1U,DW.Y(),D1V);
1133
1134 V2.SetLinearForm(D2W.X(), D1U, D2W.Y(), D1V, 2.*DW.X()*DW.Y(),D2UV);
1135 V2.SetLinearForm(DW.X()*DW.X(), D2U, DW.Y()*DW.Y(), D2V, V2);
1136 V3=SetLinearForm( DW, D2W, D3W, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
1137 }
1138 else
1139 if (myType == GeomAbs_Line ) {
1140 ElCLib::D1(U,myLin,P,V1);
1141 V2.SetCoord(0.,0.,0.);
1142 V3.SetCoord(0.,0.,0.);
1143 }
1144 else if (myType == GeomAbs_Circle) ElCLib::D3(U,myCirc,P,V1,V2,V3);
1145 else {
1146 myCurve->D3(U,UV,DW,D2W,D3W);
1147 mySurface->D3(UV.X(),UV.Y(),P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
1148 V1.SetLinearForm(DW.X(),D1U,DW.Y(),D1V);
1149
1150 V2.SetLinearForm(D2W.X(), D1U, D2W.Y(), D1V, 2.*DW.X()*DW.Y(),D2UV);
1151 V2.SetLinearForm(DW.X()*DW.X(), D2U, DW.Y()*DW.Y(), D2V, V2);
1152 V3=SetLinearForm( DW, D2W, D3W, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
1153 }
1154}
1155
1156
1157//=======================================================================
1158//function : DN
1159//purpose :
1160//=======================================================================
1161
1162gp_Vec Adaptor3d_CurveOnSurface::DN
1163 (const Standard_Real U,
1164 const Standard_Integer N) const
1165{
1166 gp_Pnt P;
1167 gp_Vec V1, V2, V;
1168 switch (N) {
1169 case 1:
1170 D1(U,P,V);
1171 break ;
1172 case 2:
1173 D2(U,P,V1,V);
1174 break ;
1175 case 3:
1176 D3(U,P,V1,V2,V);
1177 break ;
1178 default:
1179 Standard_NotImplemented::Raise("Adaptor3d_CurveOnSurface:DN");
1180 break;
1181 }
1182 return V;
1183}
1184
1185
1186//=======================================================================
1187//function : Resolution
1188//purpose :
1189//=======================================================================
1190
1191Standard_Real Adaptor3d_CurveOnSurface::Resolution
1192 (const Standard_Real R3d) const
1193{
1194 Standard_Real ru,rv;
1195 ru = mySurface->UResolution(R3d);
1196 rv = mySurface->VResolution(R3d);
1197 return myCurve->Resolution(Min(ru,rv));
1198}
1199
1200
1201//=======================================================================
1202//function : GetType
1203//purpose :
1204//=======================================================================
1205
1206GeomAbs_CurveType Adaptor3d_CurveOnSurface::GetType() const
1207{
1208 return myType;
1209}
1210
1211
1212//=======================================================================
1213//function : Line
1214//purpose :
1215//=======================================================================
1216
1217gp_Lin Adaptor3d_CurveOnSurface::Line() const
1218{
1219 Standard_NoSuchObject_Raise_if(myType != GeomAbs_Line, "Adaptor3d_CurveOnSurface::Line(): curve is not a line")
1220 return myLin;
1221}
1222
1223//=======================================================================
1224//function : Circle
1225//purpose :
1226//=======================================================================
1227
1228gp_Circ Adaptor3d_CurveOnSurface::Circle() const
1229{
1230 Standard_NoSuchObject_Raise_if(myType != GeomAbs_Circle, "Adaptor3d_CurveOnSurface::Line(): curve is not a circle")
1231 return myCirc;
1232}
1233
1234//=======================================================================
1235//function : Ellipse
1236//purpose :
1237//=======================================================================
1238
1239gp_Elips Adaptor3d_CurveOnSurface::Ellipse() const
1240{
1241 return to3d(mySurface->Plane(),myCurve->Ellipse());
1242}
1243
1244//=======================================================================
1245//function : Hyperbola
1246//purpose :
1247//=======================================================================
1248
1249gp_Hypr Adaptor3d_CurveOnSurface::Hyperbola() const
1250{
1251 return to3d(mySurface->Plane(),myCurve->Hyperbola());
1252}
1253
1254//=======================================================================
1255//function : Parabola
1256//purpose :
1257//=======================================================================
1258
1259gp_Parab Adaptor3d_CurveOnSurface::Parabola() const
1260{
1261 return to3d(mySurface->Plane(),myCurve->Parabola());
1262}
1263
1264Standard_Integer Adaptor3d_CurveOnSurface::Degree() const
1265{
1266
1267 // on a parametric surface should multiply
1268 // return TheCurve2dTool::Degree(myCurve);
1269
1270 return myCurve->Degree();
1271}
1272
1273//=======================================================================
1274//function : IsRational
1275//purpose :
1276//=======================================================================
1277
1278Standard_Boolean Adaptor3d_CurveOnSurface::IsRational() const
1279{
1280 return ( myCurve->IsRational() ||
1281 mySurface->IsURational() ||
1282 mySurface->IsVRational() );
1283}
1284
1285//=======================================================================
1286//function : NbPoles
1287//purpose :
1288//=======================================================================
1289
1290Standard_Integer Adaptor3d_CurveOnSurface::NbPoles() const
1291{
1292 // on a parametric surface should multiply
1293 return myCurve->NbPoles();
1294}
1295
1296//=======================================================================
1297//function : NbKnots
1298//purpose :
1299//=======================================================================
1300
1301Standard_Integer Adaptor3d_CurveOnSurface::NbKnots() const {
1302 if (mySurface->GetType()==GeomAbs_Plane)
1303 return myCurve->NbKnots();
1304 else {
1305 Standard_NoSuchObject::Raise();
1306 return 0;
1307 }
1308}
1309
1310//=======================================================================
1311//function : Bezier
1312//purpose :
1313//=======================================================================
1314
1315Handle(Geom_BezierCurve) Adaptor3d_CurveOnSurface::Bezier() const
1316{
1317 Standard_NoSuchObject_Raise_if
1318 ( mySurface->GetType() != GeomAbs_Plane,
1319 "Adaptor3d_CurveOnSurface : Bezier");
1320
1321 Handle(Geom2d_BezierCurve) Bez2d = myCurve->Bezier();
1322 Standard_Integer NbPoles = Bez2d->NbPoles();
1323
1324 const gp_Pln& Plane = mySurface->Plane();
1325
1326 TColgp_Array1OfPnt Poles(1,NbPoles);
1327 for ( Standard_Integer i=1; i<= NbPoles; i++) {
1328 Poles(i) = to3d( Plane, Bez2d->Pole(i));
1329 }
1330 Handle(Geom_BezierCurve) Bez;
1331
1332 if (Bez2d->IsRational()) {
1333 TColStd_Array1OfReal Weights(1,NbPoles);
1334 Bez2d->Weights(Weights);
1335 Bez = new Geom_BezierCurve(Poles,Weights);
1336 }
1337 else {
1338 Bez = new Geom_BezierCurve(Poles);
1339 }
1340 return Bez;
1341}
1342
1343//=======================================================================
1344//function : BSpline
1345//purpose :
1346//=======================================================================
1347
1348Handle(Geom_BSplineCurve) Adaptor3d_CurveOnSurface::BSpline() const
1349{
1350 Standard_NoSuchObject_Raise_if
1351 ( mySurface->GetType() != GeomAbs_Plane,
1352 "Adaptor3d_CurveOnSurface : BSpline");
1353
1354 Handle(Geom2d_BSplineCurve) Bsp2d = myCurve->BSpline();
1355 Standard_Integer NbPoles = Bsp2d->NbPoles();
1356
1357 const gp_Pln& Plane = mySurface->Plane();
1358
1359 TColgp_Array1OfPnt Poles(1,NbPoles);
1360 for ( Standard_Integer i=1; i<= NbPoles; i++) {
1361 Poles(i) = to3d( Plane, Bsp2d->Pole(i));
1362 }
1363
1364 TColStd_Array1OfReal Knots(1,Bsp2d->NbKnots());
1365 TColStd_Array1OfInteger Mults(1,Bsp2d->NbKnots());
1366 Bsp2d->Knots(Knots);
1367 Bsp2d->Multiplicities(Mults);
1368
1369 Handle(Geom_BSplineCurve) Bsp;
1370
1371 if (Bsp2d->IsRational()) {
1372 TColStd_Array1OfReal Weights(1,NbPoles);
1373 Bsp2d->Weights(Weights);
1374 Bsp = new Geom_BSplineCurve(Poles,Weights,Knots,Mults,
1375 Bsp2d->Degree(),
1376 Bsp2d->IsPeriodic());
1377 }
1378 else {
1379 Bsp = new Geom_BSplineCurve(Poles,Knots,Mults,
1380 Bsp2d->Degree(),
1381 Bsp2d->IsPeriodic());
1382 }
1383 return Bsp;
1384}
1385
1386//=======================================================================
1387//function : GetCurve
1388//purpose :
1389//=======================================================================
1390
1391const Handle(Adaptor2d_HCurve2d)& Adaptor3d_CurveOnSurface::GetCurve() const
1392{
1393 return myCurve;
1394}
1395
1396//=======================================================================
1397//function : GetSurface
1398//purpose :
1399//=======================================================================
1400
1401const Handle(Adaptor3d_HSurface)& Adaptor3d_CurveOnSurface::GetSurface() const
1402{
1403 return mySurface;
1404}
1405
1406//=======================================================================
1407//function : ChangeCurve
1408//purpose :
1409//=======================================================================
1410
1411Handle(Adaptor2d_HCurve2d)& Adaptor3d_CurveOnSurface::ChangeCurve()
1412{
1413 return myCurve;
1414}
1415
1416//=======================================================================
1417//function : ChangeSurface
1418//purpose :
1419//=======================================================================
1420
1421Handle(Adaptor3d_HSurface)& Adaptor3d_CurveOnSurface::ChangeSurface() {
1422 return mySurface;
1423}
1424
1425//=======================================================================
1426//function : EvalKPart
1427//purpose :
1428//=======================================================================
1429
1430void Adaptor3d_CurveOnSurface::EvalKPart()
1431{
1432 myType = GeomAbs_OtherCurve;
1433
1434 GeomAbs_SurfaceType STy = mySurface->GetType();
1435 GeomAbs_CurveType CTy = myCurve->GetType();
1436 if (STy == GeomAbs_Plane) {
1437 myType = CTy;
1438 if (myType == GeomAbs_Circle)
1439 myCirc = to3d(mySurface->Plane(),myCurve->Circle());
1440 else if (myType == GeomAbs_Line) {
1441 gp_Pnt P;
1442 gp_Vec V;
1443 gp_Pnt2d Puv;
1444 gp_Vec2d Duv;
1445 myCurve->D1(0.,Puv,Duv);
1446 gp_Vec D1U,D1V;
1447 mySurface->D1(Puv.X(),Puv.Y(),P,D1U,D1V);
1448 V.SetLinearForm(Duv.X(),D1U,Duv.Y(),D1V);
1449 myLin = gp_Lin(P,V);
1450 }
1451 }
1452 else {
1453 if ( CTy == GeomAbs_Line) {
1454 gp_Dir2d D = myCurve->Line().Direction();
1455 if ( D.IsParallel(gp::DX2d(),Precision::Angular())) { // Iso V.
1456 if ( STy == GeomAbs_Sphere) {
1457 gp_Pnt2d P = myCurve->Line().Location();
c6541a0c 1458 if ( Abs( Abs(P.Y()) -M_PI/2. ) >= Precision::PConfusion()) {
7fd59977 1459 myType = GeomAbs_Circle;
1460 gp_Sphere Sph = mySurface->Sphere();
1461 gp_Ax3 Axis = Sph.Position();
1462 myCirc = ElSLib::SphereVIso(Axis,
1463 Sph.Radius(),
1464 P.Y());
1465 gp_Dir DRev = Axis.XDirection().Crossed(Axis.YDirection());
1466 gp_Ax1 AxeRev(Axis.Location(), DRev);
1467 myCirc.Rotate(AxeRev, P.X());
1468 if ( D.IsOpposite(gp::DX2d(),Precision::Angular())) {
1469 gp_Ax2 Ax = myCirc.Position();
1470 Ax.SetDirection(Ax.Direction().Reversed());
1471 myCirc.SetPosition(Ax);
1472 }
1473 }
1474 }
1475 else if ( STy == GeomAbs_Cylinder) {
1476 myType = GeomAbs_Circle;
1477 gp_Cylinder Cyl = mySurface->Cylinder();
1478 gp_Pnt2d P = myCurve->Line().Location();
1479 gp_Ax3 Axis = Cyl.Position();
1480 myCirc = ElSLib::CylinderVIso(Axis,
1481 Cyl.Radius(),
1482 P.Y());
1483 gp_Dir DRev = Axis.XDirection().Crossed(Axis.YDirection());
1484 gp_Ax1 AxeRev(Axis.Location(), DRev);
1485 myCirc.Rotate(AxeRev, P.X());
1486 if ( D.IsOpposite(gp::DX2d(),Precision::Angular())) {
1487 gp_Ax2 Ax = myCirc.Position();
1488 Ax.SetDirection(Ax.Direction().Reversed());
1489 myCirc.SetPosition(Ax);
1490 }
1491 }
1492 else if ( STy == GeomAbs_Cone) {
1493 myType = GeomAbs_Circle;
1494 gp_Cone Cone = mySurface->Cone();
1495 gp_Pnt2d P = myCurve->Line().Location();
1496 gp_Ax3 Axis = Cone.Position();
1497 myCirc = ElSLib::ConeVIso(Axis,
1498 Cone.RefRadius(),
1499 Cone.SemiAngle(),
1500 P.Y());
1501 gp_Dir DRev = Axis.XDirection().Crossed(Axis.YDirection());
1502 gp_Ax1 AxeRev(Axis.Location(), DRev);
1503 myCirc.Rotate(AxeRev, P.X());
1504 if ( D.IsOpposite(gp::DX2d(),Precision::Angular())) {
1505 gp_Ax2 Ax = myCirc.Position();
1506 Ax.SetDirection(Ax.Direction().Reversed());
1507 myCirc.SetPosition(Ax);
1508 }
1509 }
1510 else if ( STy == GeomAbs_Torus) {
1511 myType = GeomAbs_Circle;
1512 gp_Torus Tore = mySurface->Torus();
1513 gp_Pnt2d P = myCurve->Line().Location();
1514 gp_Ax3 Axis = Tore.Position();
1515 myCirc = ElSLib::TorusVIso(Axis,
1516 Tore.MajorRadius(),
1517 Tore.MinorRadius(),
1518 P.Y());
1519 gp_Dir DRev = Axis.XDirection().Crossed(Axis.YDirection());
1520 gp_Ax1 AxeRev(Axis.Location(), DRev);
1521 myCirc.Rotate(AxeRev, P.X());
1522 if ( D.IsOpposite(gp::DX2d(),Precision::Angular())) {
1523 gp_Ax2 Ax = myCirc.Position();
1524 Ax.SetDirection(Ax.Direction().Reversed());
1525 myCirc.SetPosition(Ax);
1526 }
1527 }
1528 }
1529 else if ( D.IsParallel(gp::DY2d(),Precision::Angular())) { // Iso U.
1530 if ( STy == GeomAbs_Sphere) {
1531 myType = GeomAbs_Circle;
1532 gp_Sphere Sph = mySurface->Sphere();
1533 gp_Pnt2d P = myCurve->Line().Location();
1534 gp_Ax3 Axis = Sph.Position();
1535 // calcul de l'iso 0.
1536 myCirc = ElSLib::SphereUIso(Axis, Sph.Radius(),0.);
1537
1538 // mise a sameparameter (rotation du cercle - decalage du Y)
1539 gp_Dir DRev = Axis.XDirection().Crossed(Axis. Direction());
1540 gp_Ax1 AxeRev(Axis.Location(),DRev);
1541 myCirc.Rotate(AxeRev, P.Y());
1542
1543 // transformation en iso U ( = P.X())
1544 DRev = Axis.XDirection().Crossed(Axis.YDirection());
1545 AxeRev = gp_Ax1(Axis.Location(), DRev);
1546 myCirc.Rotate(AxeRev, P.X());
1547
1548 if ( D.IsOpposite(gp::DY2d(),Precision::Angular())) {
1549 gp_Ax2 Ax = myCirc.Position();
1550 Ax.SetDirection(Ax.Direction().Reversed());
1551 myCirc.SetPosition(Ax);
1552 }
1553 }
1554 else if ( STy == GeomAbs_Cylinder) {
1555 myType = GeomAbs_Line;
1556 gp_Cylinder Cyl = mySurface->Cylinder();
1557 gp_Pnt2d P = myCurve->Line().Location();
1558 myLin = ElSLib::CylinderUIso(Cyl.Position(),
1559 Cyl.Radius(),
1560 P.X());
1561 gp_Vec Tr(myLin.Direction());
1562 Tr.Multiply(P.Y());
1563 myLin.Translate(Tr);
1564 if ( D.IsOpposite(gp::DY2d(),Precision::Angular()))
1565 myLin.Reverse();
1566 }
1567 else if ( STy == GeomAbs_Cone) {
1568 myType = GeomAbs_Line;
1569 gp_Cone Cone = mySurface->Cone();
1570 gp_Pnt2d P = myCurve->Line().Location();
1571 myLin = ElSLib::ConeUIso(Cone.Position(),
1572 Cone.RefRadius(),
1573 Cone.SemiAngle(),
1574 P.X());
1575 gp_Vec Tr(myLin.Direction());
1576 Tr.Multiply(P.Y());
1577 myLin.Translate(Tr);
1578 if ( D.IsOpposite(gp::DY2d(),Precision::Angular()))
1579 myLin.Reverse();
1580 }
1581 else if ( STy == GeomAbs_Torus) {
1582 myType = GeomAbs_Circle;
1583 gp_Torus Tore = mySurface->Torus();
1584 gp_Pnt2d P = myCurve->Line().Location();
1585 gp_Ax3 Axis = Tore.Position();
1586 myCirc = ElSLib::TorusUIso(Axis,
1587 Tore.MajorRadius(),
1588 Tore.MinorRadius(),
1589 P.X());
1590 myCirc.Rotate(myCirc.Axis(),P.Y());
1591
1592 if ( D.IsOpposite(gp::DY2d(),Precision::Angular())) {
1593 gp_Ax2 Ax = myCirc.Position();
1594 Ax.SetDirection(Ax.Direction().Reversed());
1595 myCirc.SetPosition(Ax);
1596 }
1597 }
1598 }
1599 }
1600 }
1601}
1602//=======================================================================
1603//function :EvalFirstLastSurf
1604//purpose :
1605//=======================================================================
1606
1607void Adaptor3d_CurveOnSurface::EvalFirstLastSurf()
1608{
1609 Standard_Real FirstPar,LastPar;
1610 gp_Pnt2d UV, LeftBot, RightTop;
1611 gp_Vec2d DUV;
1612 Standard_Real Tol= Precision::PConfusion()/10;
1613 Standard_Boolean Ok = Standard_True;
1614
1615
1616 FirstPar=myCurve->FirstParameter();
1617 myCurve->D1(FirstPar,UV,DUV);
1618
1619 if(DUV.Magnitude() <= Tol) Ok = Standard_False;
1620
1621 if(Ok) {
1622
1623 switch(mySurface->GetType()) {
1624 case GeomAbs_BSplineSurface :
1625 LocatePart(UV,DUV,mySurface,LeftBot,RightTop);
1626 break;
1627 case GeomAbs_SurfaceOfRevolution :
1628 case GeomAbs_SurfaceOfExtrusion :
1629 Ok = LocatePart_RevExt(UV,DUV,mySurface,LeftBot,RightTop);
1630 break;
1631 case GeomAbs_OffsetSurface :
1632 Ok = LocatePart_Offset(UV,DUV,mySurface,LeftBot,RightTop);
1633 break;
1634 default :
1635 Standard_NotImplemented::Raise("Adaptor3d_CurveOnSurface::EvalFirstLastSurf");
1636 break;
1637 }
1638 }
1639
1640 if (Ok) {
1641
1642 CompareBounds(LeftBot,RightTop); //SVV
1643
1644 myFirstSurf = mySurface->UTrim(LeftBot.X(),RightTop.X(),Tol);
1645 myFirstSurf = myFirstSurf->VTrim(LeftBot.Y(),RightTop.Y(),Tol);
1646
1647 }
1648 else {
1649 myFirstSurf = mySurface;
1650 }
1651
1652 LastPar=myCurve->LastParameter();
1653 Ok = Standard_True;
1654 myCurve->D1(LastPar,UV,DUV);
1655 DUV.Reverse(); //We want the other part
1656
1657 if(DUV.Magnitude() <= Tol) Ok = Standard_False;
1658
1659 if(Ok) {
1660
1661 switch(mySurface->GetType()) {
1662 case GeomAbs_BSplineSurface :
1663 LocatePart(UV,DUV,mySurface,LeftBot,RightTop);
1664 break;
1665 case GeomAbs_SurfaceOfRevolution :
1666 case GeomAbs_SurfaceOfExtrusion :
1667 Ok = LocatePart_RevExt(UV,DUV,mySurface,LeftBot,RightTop);
1668 break;
1669 case GeomAbs_OffsetSurface :
1670 Ok = LocatePart_Offset(UV,DUV,mySurface,LeftBot,RightTop);
1671 break;
1672 default :
1673 Standard_NotImplemented::Raise("Adaptor3d_CurveOnSurface::EvalFirstLastSurf");
1674 break;
1675 }
1676 }
1677
1678 if (Ok) {
1679
1680 CompareBounds(LeftBot, RightTop); //SVV
1681
1682 myLastSurf = mySurface->UTrim(LeftBot.X(),RightTop.X(),Tol);
1683 myLastSurf = myLastSurf->VTrim(LeftBot.Y(),RightTop.Y(),Tol);
1684
1685 }
1686 else {
1687 myLastSurf = mySurface;
1688 }
1689}
1690
1691//=======================================================================
1692//function :LocatePart_RevExt
1693//purpose : processes Knots
1694//=======================================================================
1695
1696Standard_Boolean Adaptor3d_CurveOnSurface::LocatePart_RevExt(const gp_Pnt2d& UV,
1697 const gp_Vec2d& DUV,
1698 const Handle(Adaptor3d_HSurface)& S,
1699 gp_Pnt2d& LeftBot,
1700 gp_Pnt2d& RightTop) const
1701{
1702 Handle(Adaptor3d_HCurve) AHC = S->BasisCurve();
1703
1704 if (AHC->GetType() == GeomAbs_BSplineCurve) {
1705 Handle( Geom_BSplineCurve) BSplC;
1706 BSplC = AHC->BSpline();
1707
1708 if((S->GetType())==GeomAbs_SurfaceOfExtrusion) {
1709 Locate1Coord(1,UV,DUV,BSplC,LeftBot,RightTop);
1710 Locate2Coord(2,UV,DUV,S->FirstVParameter(),S->LastVParameter(),LeftBot,RightTop);
1711 }
1712 else if((S->GetType())==GeomAbs_SurfaceOfRevolution) {
1713 Locate1Coord(2,UV,DUV,BSplC,LeftBot,RightTop);
1714 Locate2Coord(1,UV,DUV,S->FirstUParameter(),S->LastUParameter(),LeftBot,RightTop);
1715 }
1716
1717 Standard_Real u1,u2,v1,v2;
1718 ReverseParam(LeftBot.X(),RightTop.X(),u1,u2);
1719 LeftBot.SetX(u1);
1720 RightTop.SetX(u2);
1721 ReverseParam(LeftBot.Y(),RightTop.Y(),v1,v2);
1722 LeftBot.SetY(v1);
1723 RightTop.SetY(v2);
1724 return Standard_True;
1725 }
1726 return Standard_False;
1727}
1728
1729//=======================================================================
1730//function :LocatePart_OffsetSurface
1731//purpose :
1732//=======================================================================
1733
1734Standard_Boolean Adaptor3d_CurveOnSurface::
1735 LocatePart_Offset(const gp_Pnt2d& UV, const gp_Vec2d& DUV,
1736 const Handle(Adaptor3d_HSurface)& S,
1737 gp_Pnt2d& LeftBot, gp_Pnt2d& RightTop) const
1738{
1739 Standard_Boolean Ok = Standard_True;
1740 Handle( Adaptor3d_HSurface) AHS;
1741 Handle( Geom_BSplineSurface) BSplS;
1742 AHS = S->BasisSurface();
1743 GeomAbs_SurfaceType BasisSType = AHS->GetType();
1744 switch(BasisSType) {
1745 case GeomAbs_SurfaceOfRevolution:
1746 case GeomAbs_SurfaceOfExtrusion :
1747 Ok = LocatePart_RevExt(UV,DUV,AHS,LeftBot,RightTop);
1748 break;
1749
1750 case GeomAbs_BSplineSurface:
1751 LocatePart(UV,DUV,AHS,LeftBot,RightTop);
1752 break;
1753
1754 default :
1755 Ok=Standard_False;
1756 }
1757 return Ok;
1758}
1759
1760//=======================================================================
1761//function :LocatePart
1762//purpose : for BSplineSurface
1763//=======================================================================
1764
1765void Adaptor3d_CurveOnSurface::LocatePart(const gp_Pnt2d& UV, const gp_Vec2d& DUV,
1766 const Handle(Adaptor3d_HSurface)& S,
1767 gp_Pnt2d& LeftBot, gp_Pnt2d& RightTop) const
1768{
1769 Handle( Geom_BSplineSurface) BSplS;
1770 BSplS = S->BSpline();
1771 Standard_Boolean DUIsNull=Standard_False,
1772 DVIsNull=Standard_False;
1773
1774 Locate1Coord(1,UV,DUV,BSplS,DUIsNull,LeftBot,RightTop);
1775 Locate1Coord(2,UV,DUV,BSplS,DVIsNull,LeftBot,RightTop);
1776
1777 if((DUIsNull==Standard_True)&&(DVIsNull==Standard_False)) {
1778 TColStd_Array1OfReal ArrU(1,BSplS->NbUKnots());
1779 BSplS->UKnots(ArrU);
1780 Locate2Coord(1,UV,DUV,BSplS,ArrU,LeftBot,RightTop);
1781 }
1782 else if((DVIsNull==Standard_True)&&(DUIsNull==Standard_False)) {
1783 TColStd_Array1OfReal ArrV(1,BSplS->NbVKnots());
1784 BSplS->VKnots(ArrV);
1785 Locate2Coord(2,UV,DUV,BSplS,ArrV,LeftBot,RightTop);
1786 }
1787}
1788
1789
1790
Open CASCADE Technology repository