0025981: Wrong result obtained by projection algorithm.
[occt.git] / src / ProjLib / ProjLib_ProjectedCurve.cxx
1 // Created on: 1993-08-25
2 // Created by: Bruno DUMORTIER
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 //  Modified by skv - Wed Aug 11 15:45:58 2004 OCC6272
18
19 #include <GeomAbs_SurfaceType.hxx>
20 #include <Standard_NoSuchObject.hxx>
21 #include <Standard_NotImplemented.hxx>
22 #include <ProjLib_ProjectedCurve.hxx>
23 #include <ProjLib_CompProjectedCurve.hxx>
24 #include <ProjLib_HCompProjectedCurve.hxx>
25 #include <ProjLib_ComputeApproxOnPolarSurface.hxx>
26 #include <ProjLib_ComputeApprox.hxx>
27 #include <ProjLib_Projector.hxx>
28 #include <Adaptor3d_HCurve.hxx>
29 #include <Adaptor3d_HSurface.hxx>
30 #include <Approx_CurveOnSurface.hxx>
31 #include <ProjLib_Plane.hxx>
32 #include <ProjLib_Cylinder.hxx>
33 #include <ProjLib_Cone.hxx>
34 #include <ProjLib_Sphere.hxx>
35 #include <ProjLib_Torus.hxx>
36 #include <Precision.hxx>
37 #include <Geom2d_BSplineCurve.hxx>
38 #include <Geom2d_BezierCurve.hxx>
39 #include <gp_Vec2d.hxx>
40 #include <StdFail_NotDone.hxx>
41 #include <gp_XY.hxx>
42 #include <TColgp_HArray1OfPnt2d.hxx>
43 #include <TColStd_HArray1OfReal.hxx>
44 #include <Geom2dConvert_CompCurveToBSplineCurve.hxx>
45 #include <TColStd_Array1OfReal.hxx>
46 #include <TColStd_Array1OfInteger.hxx>
47 #include <TColgp_Array1OfPnt2d.hxx>
48 #include <TColgp_HArray1OfVec2d.hxx>
49 #include <TColStd_HArray1OfBoolean.hxx>
50 #include <BSplCLib.hxx>
51 #include <GeomAbs_IsoType.hxx>
52 #include <Geom2d_Line.hxx>
53 #include <Geom2d_TrimmedCurve.hxx>
54 #include <ElCLib.hxx>
55 #include <GeomLib.hxx>
56 #include <Extrema_ExtPC.hxx>
57 #include <NCollection_DataMap.hxx>
58
59 //=======================================================================
60 //function : IsoIsDeg
61 //purpose  : 
62 //=======================================================================
63
64 static Standard_Boolean IsoIsDeg  (const Adaptor3d_Surface& S,
65                                    const Standard_Real      Param,
66                                    const GeomAbs_IsoType    IT,
67                                    const Standard_Real      TolMin,
68                                    const Standard_Real      TolMax) 
69 {
70     Standard_Real U1=0.,U2=0.,V1=0.,V2=0.,T;
71     Standard_Boolean Along = Standard_True;
72     U1 = S.FirstUParameter();
73     U2 = S.LastUParameter();
74     V1 = S.FirstVParameter();
75     V2 = S.LastVParameter();
76     gp_Vec D1U,D1V;
77     gp_Pnt P;
78     Standard_Real Step,D1NormMax;
79     if (IT == GeomAbs_IsoV) 
80     {
81       Step = (U2 - U1)/10;
82       D1NormMax=0.;
83       for (T=U1;T<=U2;T=T+Step) 
84       {
85         S.D1(T,Param,P,D1U,D1V);
86         D1NormMax=Max(D1NormMax,D1U.Magnitude());
87       }
88
89       if (D1NormMax >TolMax || D1NormMax < TolMin ) 
90            Along = Standard_False;
91     }
92     else 
93     {
94       Step = (V2 - V1)/10;
95       D1NormMax=0.;
96       for (T=V1;T<=V2;T=T+Step) 
97       {
98         S.D1(Param,T,P,D1U,D1V);
99         D1NormMax=Max(D1NormMax,D1V.Magnitude());
100       }
101
102       if (D1NormMax >TolMax || D1NormMax < TolMin ) 
103            Along = Standard_False;
104
105
106     }
107     return Along;
108 }
109
110 //=======================================================================
111 //function : TrimC3d
112 //purpose  : 
113 //=======================================================================
114
115 static void TrimC3d(Handle(Adaptor3d_HCurve)& myCurve,
116                     Standard_Boolean* IsTrimmed,
117                     const Standard_Real dt,
118                     const gp_Pnt& Pole,
119                     Standard_Integer* SingularCase,
120                     const Standard_Integer NumberOfSingularCase)
121 {
122   Standard_Real f = myCurve->FirstParameter();
123   Standard_Real l = myCurve->LastParameter();
124
125   gp_Pnt P = myCurve->Value(f);
126
127   if(P.Distance(Pole) < Precision::Confusion()) {
128     IsTrimmed[0] = Standard_True;
129     f = f+dt;
130     myCurve = myCurve->Trim(f, l, Precision::Confusion());
131     SingularCase[0] = NumberOfSingularCase;
132   }
133   
134   P = myCurve->Value(l);
135   if(P.Distance(Pole) < Precision::Confusion()) {
136     IsTrimmed[1] = Standard_True;
137     l = l-dt;
138     myCurve = myCurve->Trim(f, l, Precision::Confusion());
139     SingularCase[1] = NumberOfSingularCase;
140   }
141 }
142
143 //=======================================================================
144 //function : ExtendC2d
145 //purpose  : 
146 //=======================================================================
147
148 static void ExtendC2d (Handle(Geom2d_BSplineCurve)& aRes,
149                        const Standard_Real /*t*/,
150                        const Standard_Real /*dt*/,
151                        const Standard_Real u1,
152                        const Standard_Real u2,
153                        const Standard_Real v1,
154                        const Standard_Real v2,
155                        const Standard_Integer FirstOrLast,
156                        const Standard_Integer NumberOfSingularCase)
157 {
158   Standard_Real theParam = (FirstOrLast == 0)? aRes->FirstParameter()
159     : aRes->LastParameter();
160
161   gp_Pnt2d                              aPBnd;
162   gp_Vec2d                              aVBnd;
163   gp_Dir2d                              aDBnd;
164   Handle(Geom2d_TrimmedCurve)           aSegment;
165   Geom2dConvert_CompCurveToBSplineCurve aCompCurve(aRes, Convert_RationalC1);
166   Standard_Real                         aTol = Precision::Confusion();
167
168   aRes->D1(theParam, aPBnd, aVBnd);
169   aDBnd.SetXY(aVBnd.XY());
170   gp_Lin2d aLin(aPBnd, aDBnd); //line in direction of derivative
171
172   gp_Pnt2d thePole;
173   gp_Dir2d theBoundDir;
174   switch (NumberOfSingularCase)
175   {
176   case 1:
177     {
178       thePole.SetCoord(u1, v1);
179       theBoundDir.SetCoord(0., 1.);
180       break;
181     }
182   case 2:
183     {
184       thePole.SetCoord(u2, v1);
185       theBoundDir.SetCoord(0., 1.);
186       break;
187     }
188   case 3:
189     {
190       thePole.SetCoord(u1, v1);
191       theBoundDir.SetCoord(1., 0.);
192       break;
193     }
194   case 4:
195     {
196       thePole.SetCoord(u1, v2);
197       theBoundDir.SetCoord(1., 0.);
198       break;
199     }
200   }
201   gp_Lin2d BoundLin(thePole, theBoundDir); //one of the bounds of rectangle
202
203   Standard_Real U1x = BoundLin.Direction().X();
204   Standard_Real U1y = BoundLin.Direction().Y();
205   Standard_Real U2x = aLin.Direction().X();
206   Standard_Real U2y = aLin.Direction().Y();
207   Standard_Real Uo21x = aLin.Location().X() - BoundLin.Location().X();
208   Standard_Real Uo21y = aLin.Location().Y() - BoundLin.Location().Y();
209   
210   Standard_Real D = U1y*U2x-U1x*U2y;
211   
212   Standard_Real ParOnLin = (Uo21y * U1x - Uo21x * U1y)/D; //parameter of intersection point
213   
214   Handle(Geom2d_Line) aSegLine = new Geom2d_Line(aLin);
215   aSegment = (FirstOrLast == 0)?
216     new Geom2d_TrimmedCurve(aSegLine, ParOnLin, 0.) :
217     new Geom2d_TrimmedCurve(aSegLine, 0., ParOnLin);
218
219   aCompCurve.Add(aSegment, aTol);
220   aRes = aCompCurve.BSplineCurve();
221 }
222
223 //=======================================================================
224 //function : Project
225 //purpose  : 
226 //=======================================================================
227
228 static void Project(ProjLib_Projector& P, Handle(Adaptor3d_HCurve)& C)
229 {
230   GeomAbs_CurveType CType = C->GetType();
231   switch (CType) {
232     case GeomAbs_Line:
233       P.Project(C->Line());
234       break;
235     case GeomAbs_Circle:
236       P.Project(C->Circle());
237       break;
238     case GeomAbs_Ellipse:
239       P.Project(C->Ellipse());
240       break;
241     case GeomAbs_Hyperbola:
242       P.Project(C->Hyperbola());
243       break;
244     case GeomAbs_Parabola:
245       P.Project(C->Parabola());
246       break;
247     case GeomAbs_BSplineCurve:
248     case GeomAbs_BezierCurve:
249     case GeomAbs_OtherCurve:    // try the approximation
250       break;
251     default:
252       Standard_NoSuchObject::Raise(" ");
253   }
254 }
255
256 //=======================================================================
257 //function : ProjLib_ProjectedCurve
258 //purpose  : 
259 //=======================================================================
260
261 ProjLib_ProjectedCurve::ProjLib_ProjectedCurve()
262
263 {
264   myTolerance = Precision::Confusion();
265 }
266
267
268 //=======================================================================
269 //function : ProjLib_ProjectedCurve
270 //purpose  : 
271 //=======================================================================
272
273 ProjLib_ProjectedCurve::ProjLib_ProjectedCurve
274 (const Handle(Adaptor3d_HSurface)& S)
275 {
276   myTolerance = Precision::Confusion();
277   Load(S);
278 }
279
280
281 //=======================================================================
282 //function : ProjLib_ProjectedCurve
283 //purpose  : 
284 //=======================================================================
285
286 ProjLib_ProjectedCurve::ProjLib_ProjectedCurve
287 (const Handle(Adaptor3d_HSurface)& S,
288  const Handle(Adaptor3d_HCurve)& C)
289 {
290   myTolerance = Precision::Confusion();
291   Load(S);
292   Load(C);
293 }
294
295
296 //=======================================================================
297 //function : ProjLib_ProjectedCurve
298 //purpose  : 
299 //=======================================================================
300
301 ProjLib_ProjectedCurve::ProjLib_ProjectedCurve
302 (const Handle(Adaptor3d_HSurface)& S,
303  const Handle(Adaptor3d_HCurve)&   C,
304  const Standard_Real             Tol)
305 {
306   myTolerance = Max(Tol, Precision::Confusion());
307   Load(S);
308   Load(C);
309 }
310
311
312 //=======================================================================
313 //function : Load
314 //purpose  : 
315 //=======================================================================
316
317 void ProjLib_ProjectedCurve::Load(const Handle(Adaptor3d_HSurface)& S)
318 {
319   mySurface = S ;
320 }
321
322
323 //=======================================================================
324 //function : Load
325 //purpose  : 
326 //=======================================================================
327
328 void ProjLib_ProjectedCurve::Load(const Handle(Adaptor3d_HCurve)& C)
329 {
330   myTolerance = Max(myTolerance, Precision::Confusion());
331   myCurve = C;
332   Standard_Real FirstPar = C->FirstParameter();
333   Standard_Real LastPar  = C->LastParameter();
334   GeomAbs_SurfaceType SType = mySurface->GetType();
335   GeomAbs_CurveType   CType = myCurve->GetType();
336   Standard_Boolean isAnalyticalSurf = Standard_True;
337
338   switch (SType)
339   {
340     case GeomAbs_Plane:
341       {
342         ProjLib_Plane P(mySurface->Plane());
343         Project(P,myCurve);
344         myResult = P;
345       }
346       break;
347
348     case GeomAbs_Cylinder:
349       {
350         ProjLib_Cylinder P(mySurface->Cylinder());
351         Project(P,myCurve);
352         myResult = P;
353       }
354       break;
355
356     case GeomAbs_Cone:
357       {
358         ProjLib_Cone P(mySurface->Cone());
359         Project(P,myCurve);
360         myResult = P;
361       }
362       break;
363
364     case GeomAbs_Sphere:
365       {
366         ProjLib_Sphere P(mySurface->Sphere());
367         Project(P,myCurve);
368         if ( P.IsDone())
369         {
370           // on met dans la pseudo-periode ( car Sphere n'est pas
371           // periodique en V !)
372           P.SetInBounds(myCurve->FirstParameter());
373         }
374         myResult = P;
375       }
376       break;
377
378     case GeomAbs_Torus:
379       {
380         ProjLib_Torus P(mySurface->Torus());
381         Project(P,myCurve);
382         myResult = P;
383       }
384       break;
385
386     case GeomAbs_BezierSurface:
387     case GeomAbs_BSplineSurface:
388       {
389         isAnalyticalSurf = Standard_False;
390         Standard_Boolean IsTrimmed[2] = {Standard_False, Standard_False};
391         Standard_Integer SingularCase[2];
392         Standard_Real f, l, dt;
393         const Standard_Real eps = 0.01;
394         f = myCurve->FirstParameter();
395         l = myCurve->LastParameter();
396         dt = (l - f) * eps;
397
398         Standard_Real U1 = 0.0, U2=0.0, V1=0.0, V2=0.0;
399         const Adaptor3d_Surface& S = mySurface->Surface();
400         U1 = S.FirstUParameter();
401         U2 = S.LastUParameter();
402         V1 = S.FirstVParameter();
403         V2 = S.LastVParameter();
404
405         if(IsoIsDeg(S, U1, GeomAbs_IsoU, 0., myTolerance))
406         {
407           //Surface has pole at U = Umin
408           gp_Pnt Pole = mySurface->Value(U1, V1);
409           TrimC3d(myCurve, IsTrimmed, dt, Pole, SingularCase, 1);
410         }
411
412         if(IsoIsDeg(S, U2, GeomAbs_IsoU, 0., myTolerance))
413         {
414           //Surface has pole at U = Umax
415           gp_Pnt Pole = mySurface->Value(U2, V1);
416           TrimC3d(myCurve, IsTrimmed, dt, Pole, SingularCase, 2);
417         }
418
419         if(IsoIsDeg(S, V1, GeomAbs_IsoV, 0., myTolerance))
420         {
421           //Surface has pole at V = Vmin
422           gp_Pnt Pole = mySurface->Value(U1, V1);
423           TrimC3d(myCurve, IsTrimmed, dt, Pole, SingularCase, 3);
424         }
425
426         if(IsoIsDeg(S, V2, GeomAbs_IsoV, 0., myTolerance))
427         {
428           //Surface has pole at V = Vmax
429           gp_Pnt Pole = mySurface->Value(U1, V2);
430           TrimC3d(myCurve, IsTrimmed, dt, Pole, SingularCase, 4);
431         }
432
433         ProjLib_ComputeApproxOnPolarSurface polar(myCurve, mySurface, myTolerance);
434
435         Handle(Geom2d_BSplineCurve) aRes = polar.BSpline();
436
437         if (!aRes.IsNull())
438         {
439           if( (IsTrimmed[0] || IsTrimmed[1]))
440           {
441             if(IsTrimmed[0])
442             {
443               //Add segment before start of curve
444               f = myCurve->FirstParameter();
445               ExtendC2d(aRes, f, -dt, U1, U2, V1, V2, 0, SingularCase[0]);
446             }
447             if(IsTrimmed[1])
448             {
449               //Add segment after end of curve
450               l = myCurve->LastParameter();
451               ExtendC2d(aRes, l,  dt, U1, U2, V1, V2, 1, SingularCase[1]);
452             }
453             Handle(Geom2d_Curve) NewCurve2d;
454             GeomLib::SameRange(Precision::PConfusion(), aRes,
455               aRes->FirstParameter(), aRes->LastParameter(),
456               FirstPar, LastPar, NewCurve2d);
457             aRes = Handle(Geom2d_BSplineCurve)::DownCast(NewCurve2d);
458           }
459           myResult.SetBSpline(aRes);
460           myResult.Done();
461           myResult.SetType(GeomAbs_BSplineCurve);
462         }
463       }
464       break;
465
466     default:
467       {
468         isAnalyticalSurf = Standard_False;
469         Standard_Boolean IsTrimmed[2] = {Standard_False, Standard_False};
470         Standard_Real Vsingular[2] = {0.0 , 0.0}; //for surfaces of revolution
471         Standard_Real f = 0.0, l = 0.0, dt = 0.0;
472         const Standard_Real eps = 0.01;
473
474         if(mySurface->GetType() == GeomAbs_SurfaceOfRevolution)
475         {
476           //Check possible singularity
477
478           gp_Pnt P = mySurface->AxeOfRevolution().Location();
479           gp_Dir N = mySurface->AxeOfRevolution().Direction();
480
481           gp_Lin L(P, N);
482
483           f = myCurve->FirstParameter();
484           l = myCurve->LastParameter();
485           dt = (l - f) * eps;
486
487           P = myCurve->Value(f);
488           if(L.Distance(P) < Precision::Confusion())
489           {
490             IsTrimmed[0] = Standard_True;
491             f = f + dt;
492             myCurve = myCurve->Trim(f, l, Precision::Confusion());
493             // Searching the parameter on the basis curve for surface of revolution
494             Extrema_ExtPC anExtr(P, mySurface->BasisCurve()->Curve(), myTolerance);
495             if (anExtr.IsDone())
496             {
497               Standard_Integer anIndex = 1;
498               while (!anExtr.IsMin(anIndex) && anIndex < anExtr.NbExt()) anIndex++;
499               Vsingular[0] = anExtr.Point(anIndex).Parameter();
500             }
501             else
502               Vsingular[0] = ElCLib::Parameter(L, P);
503             //SingularCase[0] = 3;
504           }
505
506           P = myCurve->Value(l);
507           if(L.Distance(P) < Precision::Confusion())
508           {
509             IsTrimmed[1] = Standard_True;
510             l = l - dt;
511             myCurve = myCurve->Trim(f, l, Precision::Confusion());
512             // Searching the parameter on the basis curve for surface of revolution
513             Extrema_ExtPC anExtr(P, mySurface->BasisCurve()->Curve(), myTolerance);
514             if (anExtr.IsDone())
515             {
516               Standard_Integer anIndex = 1;
517               while (!anExtr.IsMin(anIndex) && anIndex < anExtr.NbExt()) anIndex++;
518               Vsingular[1] = anExtr.Point(anIndex).Parameter();
519             }
520             else
521               Vsingular[1] = ElCLib::Parameter(L, P);
522             //SingularCase[1] = 4;
523           }
524         }
525
526         ProjLib_CompProjectedCurve Projector(mySurface,myCurve, myTolerance, myTolerance, 100 * myTolerance);
527         Handle(ProjLib_HCompProjectedCurve) HProjector = new ProjLib_HCompProjectedCurve();
528         HProjector->Set(Projector);
529
530         // Normalement, dans le cadre de ProjLib, le resultat 
531         // doit etre une et une seule courbe !!!
532         // De plus, cette courbe ne doit pas etre Single point
533         Standard_Integer NbCurves = Projector.NbCurves();
534         Standard_Real Udeb = 0.0,Ufin = 0.0;
535         if (NbCurves > 0)
536         {
537           Projector.Bounds(1, Udeb, Ufin);
538         }
539         else 
540         {
541           return;
542         }
543         // Approximons cette courbe algorithmique.
544         Standard_Boolean Only3d = Standard_False;
545         Standard_Boolean Only2d = Standard_True;
546         GeomAbs_Shape Continuity = GeomAbs_C1;
547         Standard_Integer MaxDegree = 14;
548         Standard_Integer MaxSeg    = 16;
549
550         Approx_CurveOnSurface appr(HProjector, mySurface, Udeb, Ufin, 
551                                    myTolerance, Continuity, MaxDegree, MaxSeg, 
552                                    Only3d, Only2d);
553
554         Handle(Geom2d_BSplineCurve) aRes = appr.Curve2d();
555
556         if (!aRes.IsNull())
557         {
558           if(IsTrimmed[0] || IsTrimmed[1])
559           {
560             // Treatment only for surface of revolution
561             Standard_Real u1, u2, v1, v2;
562             u1 = mySurface->FirstUParameter();
563             u2 = mySurface->LastUParameter();
564             v1 = mySurface->FirstVParameter();
565             v2 = mySurface->LastVParameter();
566
567             if(IsTrimmed[0])
568             {
569               //Add segment before start of curve
570               ExtendC2d(aRes, f, -dt, u1, u2, Vsingular[0], v2, 0, 3);
571             }
572             if(IsTrimmed[1])
573             {
574               //Add segment after end of curve
575               ExtendC2d(aRes, l,  dt, u1, u2, v1, Vsingular[1], 1, 4);
576             }
577             Handle(Geom2d_Curve) NewCurve2d;
578             GeomLib::SameRange(Precision::PConfusion(), aRes,
579               aRes->FirstParameter(), aRes->LastParameter(),
580               FirstPar, LastPar, NewCurve2d);
581             aRes = Handle(Geom2d_BSplineCurve)::DownCast(NewCurve2d);
582           }
583
584           myResult.SetBSpline(aRes);
585           myResult.Done();
586           myResult.SetType(GeomAbs_BSplineCurve);
587         }
588       }
589   }
590
591   if ( !myResult.IsDone() && isAnalyticalSurf)
592   {
593     // Use advanced analytical projector if base analytical projection failed.
594     ProjLib_ComputeApprox Comp( myCurve, mySurface, myTolerance);
595     myResult.Done();
596
597     // set the type
598     if ( SType == GeomAbs_Plane && CType == GeomAbs_BezierCurve)
599     {
600       myResult.SetType(GeomAbs_BezierCurve);
601       myResult.SetBezier(Comp.Bezier()) ;
602     }
603     else
604     {
605       myResult.SetType(GeomAbs_BSplineCurve);
606       myResult.SetBSpline(Comp.BSpline()) ;
607     }
608     // set the periodicity flag
609     if (SType == GeomAbs_Plane        &&
610         CType == GeomAbs_BSplineCurve &&
611         myCurve->IsPeriodic()   )
612     {
613       myResult.SetPeriodic();
614     }
615     myTolerance = Comp.Tolerance();
616   }
617
618   Standard_Boolean isPeriodic[] = {mySurface->IsUPeriodic(),
619                                    mySurface->IsVPeriodic()};
620   if (myResult.IsDone() &&
621      (isPeriodic[0] || isPeriodic[1]))
622   {
623     // Check result curve to be in params space.
624
625     // U and V parameters space correspondingly.
626     const Standard_Real aSurfFirstPar[2] = {mySurface->FirstUParameter(),
627                                             mySurface->FirstVParameter()};
628     Standard_Real aSurfPeriod[2] = {0.0, 0.0};
629     if (isPeriodic[0])
630       aSurfPeriod[0] = mySurface->UPeriod();
631     if (isPeriodic[1])
632       aSurfPeriod[1] = mySurface->VPeriod();
633
634     for(Standard_Integer anIdx = 1; anIdx <= 2; anIdx++)
635     {
636       if (!isPeriodic[anIdx - 1])
637         continue;
638
639       if (myResult.GetType() == GeomAbs_BSplineCurve)
640       {
641         NCollection_DataMap<Standard_Integer, Standard_Integer> aMap; 
642         Handle(Geom2d_BSplineCurve) aRes = myResult.BSpline();
643         const Standard_Integer aDeg = aRes->Degree();
644
645         for(Standard_Integer aKnotIdx = aRes->FirstUKnotIndex();
646                              aKnotIdx < aRes->LastUKnotIndex();
647                              aKnotIdx++)
648         {
649           const Standard_Real aFirstParam = aRes->Knot(aKnotIdx);
650           const Standard_Real aLastParam  = aRes->Knot(aKnotIdx + 1);
651
652           for(Standard_Integer anIntIdx = 0; anIntIdx <= aDeg; anIntIdx++)
653           {
654             const Standard_Real aCurrParam = aFirstParam + (aLastParam - aFirstParam) * anIntIdx / (aDeg + 1.0);
655             gp_Pnt2d aPnt2d;
656             aRes->D0(aCurrParam, aPnt2d);
657
658             Standard_Integer aMapKey = Standard_Integer ((aPnt2d.Coord(anIdx) - aSurfFirstPar[anIdx - 1]) / aSurfPeriod[anIdx - 1]);
659
660             if (aPnt2d.Coord(anIdx) - aSurfFirstPar[anIdx - 1] < 0.0)
661               aMapKey--;
662
663             if (aMap.IsBound(aMapKey))
664               aMap.ChangeFind(aMapKey)++;
665             else
666               aMap.Bind(aMapKey, 1);
667           }
668         }
669
670         Standard_Integer aMaxPoints = 0, aMaxIdx = 0;
671         NCollection_DataMap<Standard_Integer, Standard_Integer>::Iterator aMapIter(aMap);
672         for( ; aMapIter.More(); aMapIter.Next())
673         {
674           if (aMapIter.Value() > aMaxPoints)
675           {
676             aMaxPoints = aMapIter.Value();
677             aMaxIdx = aMapIter.Key();
678           }
679         }
680         if (aMaxIdx != 0)
681         {
682           gp_Pnt2d aFirstPnt = aRes->Value(aRes->FirstParameter());
683           gp_Pnt2d aSecondPnt = aFirstPnt;
684           aSecondPnt.SetCoord(anIdx, aFirstPnt.Coord(anIdx) - aSurfPeriod[anIdx - 1] * aMaxIdx);
685           aRes->Translate(gp_Vec2d(aFirstPnt, aSecondPnt));
686         }
687       }
688
689       if (myResult.GetType() == GeomAbs_Line)
690       {
691         Standard_Real aT1 = myCurve->FirstParameter();
692         Standard_Real aT2 = myCurve->LastParameter();
693
694         if (anIdx == 1)
695         {
696           // U param space.
697           myResult.UFrame(aT1, aT2, aSurfFirstPar[anIdx - 1], aSurfPeriod[anIdx - 1]);
698         }
699         else
700         {
701           // V param space.
702           myResult.VFrame(aT1, aT2, aSurfFirstPar[anIdx - 1], aSurfPeriod[anIdx - 1]);
703         }
704       }
705     }
706   }
707 }
708
709
710 //=======================================================================
711 //function : GetSurface
712 //purpose  : 
713 //=======================================================================
714
715 const Handle(Adaptor3d_HSurface)& ProjLib_ProjectedCurve::GetSurface() const
716 {
717   return mySurface;
718 }
719
720
721 //=======================================================================
722 //function : GetCurve
723 //purpose  : 
724 //=======================================================================
725
726 const Handle(Adaptor3d_HCurve)& ProjLib_ProjectedCurve::GetCurve() const
727 {
728   return myCurve;
729 }
730
731
732 //=======================================================================
733 //function : GetTolerance
734 //purpose  : 
735 //=======================================================================
736
737 Standard_Real ProjLib_ProjectedCurve::GetTolerance() const 
738 {
739   return myTolerance;
740 }
741
742
743 //=======================================================================
744 //function : FirstParameter
745 //purpose  : 
746 //=======================================================================
747
748 Standard_Real ProjLib_ProjectedCurve::FirstParameter() const 
749 {
750   return myCurve->FirstParameter();
751 }
752
753
754 //=======================================================================
755 //function : LastParameter
756 //purpose  : 
757 //=======================================================================
758
759 Standard_Real ProjLib_ProjectedCurve::LastParameter() const 
760 {
761   return myCurve->LastParameter();
762 }
763
764
765 //=======================================================================
766 //function : Continuity
767 //purpose  : 
768 //=======================================================================
769
770 GeomAbs_Shape ProjLib_ProjectedCurve::Continuity() const
771 {
772   Standard_NotImplemented::Raise("");
773   return GeomAbs_C0;
774 }
775
776
777 //=======================================================================
778 //function : NbIntervals
779 //purpose  : 
780 //=======================================================================
781
782 Standard_Integer ProjLib_ProjectedCurve::NbIntervals(const GeomAbs_Shape ) const 
783 {
784   Standard_NotImplemented::Raise("");
785   return 0;
786 }
787
788
789 //=======================================================================
790 //function : Intervals
791 //purpose  : 
792 //=======================================================================
793
794 //void ProjLib_ProjectedCurve::Intervals(TColStd_Array1OfReal&  T,
795 void ProjLib_ProjectedCurve::Intervals(TColStd_Array1OfReal&  ,
796                                        const GeomAbs_Shape ) const 
797 {
798   Standard_NotImplemented::Raise("");
799 }
800
801
802 //=======================================================================
803 //function : IsClosed
804 //purpose  : 
805 //=======================================================================
806
807 Standard_Boolean ProjLib_ProjectedCurve::IsClosed() const
808 {
809   Standard_NotImplemented::Raise("");
810   return Standard_True;
811 }
812
813
814 //=======================================================================
815 //function : IsPeriodic
816 //purpose  : 
817 //=======================================================================
818
819 Standard_Boolean ProjLib_ProjectedCurve::IsPeriodic() const
820 {
821   return myResult.IsPeriodic();
822 }
823
824
825 //=======================================================================
826 //function : Period
827 //purpose  : 
828 //=======================================================================
829
830 Standard_Real ProjLib_ProjectedCurve::Period() const
831 {
832   Standard_NotImplemented::Raise("");
833   return 0.;
834 }
835
836
837 //=======================================================================
838 //function : Value
839 //purpose  : 
840 //=======================================================================
841
842 gp_Pnt2d ProjLib_ProjectedCurve::Value(const Standard_Real ) const 
843 {
844   Standard_NotImplemented::Raise("");
845   return gp_Pnt2d(0.,0.);
846 }
847
848
849 //=======================================================================
850 //function : D0
851 //purpose  : 
852 //=======================================================================
853
854 void ProjLib_ProjectedCurve::D0(const Standard_Real , gp_Pnt2d& ) const
855 {
856   Standard_NotImplemented::Raise("");
857 }
858
859
860 //=======================================================================
861 //function : D1
862 //purpose  : 
863 //=======================================================================
864
865 void ProjLib_ProjectedCurve::D1(const Standard_Real ,
866                                       gp_Pnt2d&     , 
867                                       gp_Vec2d&     ) const 
868 {
869   Standard_NotImplemented::Raise("");
870 }
871
872
873 //=======================================================================
874 //function : D2
875 //purpose  : 
876 //=======================================================================
877
878 void ProjLib_ProjectedCurve::D2(const Standard_Real , 
879                                       gp_Pnt2d&     , 
880                                       gp_Vec2d&     , 
881                                       gp_Vec2d&     ) const 
882 {
883   Standard_NotImplemented::Raise("");
884 }
885
886
887 //=======================================================================
888 //function : D3
889 //purpose  : 
890 //=======================================================================
891
892 void ProjLib_ProjectedCurve::D3(const Standard_Real, 
893                                       gp_Pnt2d&, 
894                                       gp_Vec2d&, 
895                                       gp_Vec2d&, 
896                                       gp_Vec2d&) const 
897 {
898   Standard_NotImplemented::Raise("");
899 }
900
901
902 //=======================================================================
903 //function : DN
904 //purpose  : 
905 //=======================================================================
906
907 gp_Vec2d ProjLib_ProjectedCurve::DN(const Standard_Real, 
908                                     const Standard_Integer) const 
909 {
910   Standard_NotImplemented::Raise("");
911   return gp_Vec2d(0.,0.);
912 }
913
914
915 //=======================================================================
916 //function : Resolution
917 //purpose  : 
918 //=======================================================================
919
920 Standard_Real ProjLib_ProjectedCurve::Resolution(const Standard_Real) const 
921 {
922   Standard_NotImplemented::Raise("");
923   return 0.;
924 }
925     
926
927 //=======================================================================
928 //function : GetType
929 //purpose  : 
930 //=======================================================================
931
932 GeomAbs_CurveType ProjLib_ProjectedCurve::GetType() const
933 {
934   return myResult.GetType();
935 }
936
937
938 //=======================================================================
939 //function : Line
940 //purpose  : 
941 //=======================================================================
942
943 gp_Lin2d ProjLib_ProjectedCurve::Line() const
944 {
945   return myResult.Line();
946 }
947
948
949 //=======================================================================
950 //function : Circle
951 //purpose  : 
952 //=======================================================================
953
954 gp_Circ2d ProjLib_ProjectedCurve::Circle() const
955 {
956   return myResult.Circle();
957 }
958
959
960 //=======================================================================
961 //function : Ellipse
962 //purpose  : 
963 //=======================================================================
964
965 gp_Elips2d ProjLib_ProjectedCurve::Ellipse() const
966 {
967   return myResult.Ellipse();
968 }
969
970
971 //=======================================================================
972 //function : Hyperbola
973 //purpose  : 
974 //=======================================================================
975
976 gp_Hypr2d ProjLib_ProjectedCurve::Hyperbola() const
977 {
978   return myResult.Hyperbola();
979 }
980
981
982 //=======================================================================
983 //function : Parabola
984 //purpose  : 
985 //=======================================================================
986
987 gp_Parab2d ProjLib_ProjectedCurve::Parabola() const
988 {
989   return myResult.Parabola();
990 }
991
992
993
994 //=======================================================================
995 //function : Degree
996 //purpose  : 
997 //=======================================================================
998
999 Standard_Integer ProjLib_ProjectedCurve::Degree() const
1000 {
1001   Standard_NoSuchObject_Raise_if 
1002     ( (GetType() != GeomAbs_BSplineCurve) &&
1003       (GetType() != GeomAbs_BezierCurve),
1004      "ProjLib_ProjectedCurve:Degree");
1005   if (GetType() == GeomAbs_BSplineCurve) {
1006     return myResult.BSpline()->Degree();
1007   }
1008   else if (GetType() == GeomAbs_BezierCurve) {
1009     return myResult.Bezier()->Degree();
1010   }
1011
1012   // portage WNT
1013   return 0;
1014 }
1015
1016 //=======================================================================
1017 //function : IsRational
1018 //purpose  : 
1019 //=======================================================================
1020
1021 Standard_Boolean ProjLib_ProjectedCurve::IsRational() const 
1022 {
1023   Standard_NoSuchObject_Raise_if 
1024     ( (GetType() != GeomAbs_BSplineCurve) &&
1025       (GetType() != GeomAbs_BezierCurve),
1026      "ProjLib_ProjectedCurve:IsRational");
1027   if (GetType() == GeomAbs_BSplineCurve) {
1028     return myResult.BSpline()->IsRational();
1029   }
1030   else if (GetType() == GeomAbs_BezierCurve) {
1031     return myResult.Bezier()->IsRational();
1032   }
1033   // portage WNT
1034   return Standard_False;
1035 }
1036
1037 //=======================================================================
1038 //function : NbPoles
1039 //purpose  : 
1040 //=======================================================================
1041
1042 Standard_Integer ProjLib_ProjectedCurve::NbPoles() const
1043 {
1044   Standard_NoSuchObject_Raise_if 
1045     ( (GetType() != GeomAbs_BSplineCurve) &&
1046       (GetType() != GeomAbs_BezierCurve)   
1047      ,"ProjLib_ProjectedCurve:NbPoles"  );
1048   if (GetType() == GeomAbs_BSplineCurve) {
1049     return myResult.BSpline()->NbPoles();
1050   }
1051   else if (GetType() == GeomAbs_BezierCurve) {
1052     return myResult.Bezier()->NbPoles();
1053   }
1054
1055   // portage WNT
1056   return 0;
1057 }
1058
1059 //=======================================================================
1060 //function : NbKnots
1061 //purpose  : 
1062 //=======================================================================
1063
1064 Standard_Integer ProjLib_ProjectedCurve::NbKnots() const 
1065 {
1066   Standard_NoSuchObject_Raise_if ( GetType() != GeomAbs_BSplineCurve, 
1067                                   "ProjLib_ProjectedCurve:NbKnots");
1068   return myResult.BSpline()->NbKnots();
1069 }
1070
1071 //=======================================================================
1072 //function : Bezier
1073 //purpose  : 
1074 //=======================================================================
1075
1076 Handle(Geom2d_BezierCurve) ProjLib_ProjectedCurve::Bezier() const 
1077 {
1078  return myResult.Bezier() ;
1079 }
1080
1081 //=======================================================================
1082 //function : BSpline
1083 //purpose  : 
1084 //=======================================================================
1085
1086 Handle(Geom2d_BSplineCurve) ProjLib_ProjectedCurve::BSpline() const 
1087 {
1088  return myResult.BSpline() ;
1089 }
1090 //=======================================================================
1091 //function : Trim
1092 //purpose  : 
1093 //=======================================================================
1094
1095 Handle(Adaptor2d_HCurve2d) ProjLib_ProjectedCurve::Trim 
1096 //(const Standard_Real First,
1097 // const Standard_Real Last,
1098 // const Standard_Real Tolerance) const 
1099 (const Standard_Real ,
1100  const Standard_Real ,
1101  const Standard_Real ) const 
1102 {
1103   Standard_NotImplemented::Raise("");
1104   return NULL ;
1105 }
1106