0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / Approx / Approx_CurvilinearParameter.cxx
1 // Created on: 1997-08-22
2 // Created by: Sergey SOKOLOV
3 // Copyright (c) 1997-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
18 #include <Adaptor2d_HCurve2d.hxx>
19 #include <Adaptor3d_Curve.hxx>
20 #include <Adaptor3d_CurveOnSurface.hxx>
21 #include <Adaptor3d_HCurve.hxx>
22 #include <Adaptor3d_HSurface.hxx>
23 #include <AdvApprox_ApproxAFunction.hxx>
24 #include <AdvApprox_PrefAndRec.hxx>
25 #include <Approx_CurvilinearParameter.hxx>
26 #include <Approx_CurvlinFunc.hxx>
27 #include <CPnts_AbscissaPoint.hxx>
28 #include <GCPnts_AbscissaPoint.hxx>
29 #include <Geom2d_BSplineCurve.hxx>
30 #include <Geom_BSplineCurve.hxx>
31 #include <GeomAbs_Shape.hxx>
32 #include <GeomAdaptor_HCurve.hxx>
33 #include <GeomAdaptor_HSurface.hxx>
34 #include <gp_Pnt.hxx>
35 #include <gp_Pnt2d.hxx>
36 #include <gp_Vec.hxx>
37 #include <gp_Vec2d.hxx>
38 #include <math_Vector.hxx>
39 #include <Precision.hxx>
40 #include <Standard_ConstructionError.hxx>
41 #include <Standard_OutOfRange.hxx>
42 #include <TColgp_Array1OfPnt.hxx>
43 #include <TColgp_Array1OfPnt2d.hxx>
44 #include <TColStd_Array1OfReal.hxx>
45 #include <TColStd_HArray1OfInteger.hxx>
46 #include <TColStd_HArray1OfReal.hxx>
47
48 #ifdef OCCT_DEBUG_CHRONO
49 #include <OSD_Timer.hxx>
50 static OSD_Chronometer chr_total, chr_init, chr_approx;
51
52 Standard_Real t_total, t_init, t_approx;
53 void InitChron(OSD_Chronometer& ch)
54
55     ch.Reset();
56     ch.Start();
57 }
58
59 void ResultChron( OSD_Chronometer & ch, Standard_Real & time) 
60 {
61     Standard_Real tch ;
62     ch.Stop();
63     ch.Show(tch);
64     time=time +tch;
65 }
66
67 Standard_IMPORT Standard_Integer uparam_count;
68 Standard_IMPORT Standard_Real t_uparam;
69 #endif
70
71 //=======================================================================
72 //class : Approx_CurvilinearParameter_EvalCurv
73 //purpose  : case of a free 3D curve
74 //=======================================================================
75
76 class Approx_CurvilinearParameter_EvalCurv : public AdvApprox_EvaluatorFunction
77 {
78  public:
79   Approx_CurvilinearParameter_EvalCurv (const Handle(Approx_CurvlinFunc)& theFunc, 
80                                         Standard_Real First, Standard_Real Last)
81     : fonct(theFunc) { StartEndSav[0] = First; StartEndSav[1] = Last; }
82   
83   virtual void Evaluate (Standard_Integer *Dimension,
84                          Standard_Real     StartEnd[2],
85                          Standard_Real    *Parameter,
86                          Standard_Integer *DerivativeRequest,
87                          Standard_Real    *Result, // [Dimension]
88                          Standard_Integer *ErrorCode);
89   
90  private:
91   Handle(Approx_CurvlinFunc) fonct;
92   Standard_Real StartEndSav[2];
93 };
94
95 void Approx_CurvilinearParameter_EvalCurv::Evaluate (Standard_Integer * Dimension,
96                                                      Standard_Real    * StartEnd,
97                                                      Standard_Real    * Param,
98                                                      Standard_Integer * Order,
99                                                      Standard_Real    * Result,
100                                                      Standard_Integer * ErrorCode)
101 {
102   *ErrorCode = 0;
103   Standard_Real S = *Param;
104   TColStd_Array1OfReal Res(0, 2);
105   Standard_Integer i;
106   
107 // Dimension is incorrect
108   if (*Dimension != 3) {
109     *ErrorCode = 1;
110   }
111 // Parameter is incorrect
112   if ( S < StartEnd[0] || S > StartEnd[1] ) {
113     *ErrorCode = 2;
114   }
115
116   if(StartEnd[0] != StartEndSav[0] || StartEnd[1]!= StartEndSav[1]) 
117     {
118       fonct->Trim(StartEnd[0],StartEnd[1], Precision::Confusion());
119       StartEndSav[0]=StartEnd[0];
120       StartEndSav[1]=StartEnd[1];
121     }
122
123   if(!fonct->EvalCase1(S, *Order, Res)) {
124     *ErrorCode = 3;
125   }
126
127   for(i = 0; i <= 2; i++)
128     Result[i] = Res(i);  
129 }
130
131 Approx_CurvilinearParameter::Approx_CurvilinearParameter(const Handle(Adaptor3d_HCurve)& C3D,
132                                                          const Standard_Real Tol,
133                                                          const GeomAbs_Shape Order,
134                                                          const Standard_Integer MaxDegree,
135                                                          const Standard_Integer MaxSegments)
136 : myMaxError2d1(0.0),
137   myMaxError2d2(0.0)
138 {
139 #ifdef OCCT_DEBUG_CHRONO
140   t_total = t_init = t_approx = t_uparam = 0;
141   uparam_count = 0;
142   InitChron(chr_total);
143 #endif
144   myCase = 1;
145 // Initialisation of input parameters of AdvApprox
146
147   Standard_Integer Num1DSS=0, Num2DSS=0, Num3DSS=1;
148   Handle(TColStd_HArray1OfReal) OneDTolNul, TwoDTolNul; 
149   Handle(TColStd_HArray1OfReal) ThreeDTol  = new TColStd_HArray1OfReal(1,Num3DSS);
150   ThreeDTol->Init(Tol); 
151
152 #ifdef OCCT_DEBUG_CHRONO
153   InitChron(chr_init);
154 #endif
155   Handle(Approx_CurvlinFunc) fonct = new Approx_CurvlinFunc(C3D, Tol/10);
156 #ifdef OCCT_DEBUG_CHRONO
157   ResultChron(chr_init, t_init);
158 #endif
159
160   Standard_Real FirstS = fonct->FirstParameter();
161   Standard_Real  LastS = fonct->LastParameter();
162
163   Standard_Integer NbInterv_C2 = fonct->NbIntervals(GeomAbs_C2);
164   TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2+1);
165   fonct->Intervals(CutPnts_C2,GeomAbs_C2);
166   Standard_Integer NbInterv_C3 = fonct->NbIntervals(GeomAbs_C3);
167   TColStd_Array1OfReal CutPnts_C3(1, NbInterv_C3+1);
168   fonct->Intervals(CutPnts_C3,GeomAbs_C3);
169   AdvApprox_PrefAndRec CutTool(CutPnts_C2,CutPnts_C3);
170
171 #ifdef OCCT_DEBUG_CHRONO
172   InitChron(chr_approx);
173 #endif
174
175   Approx_CurvilinearParameter_EvalCurv evC (fonct, FirstS, LastS);
176   AdvApprox_ApproxAFunction aApprox (Num1DSS, Num2DSS, Num3DSS, 
177                                      OneDTolNul, TwoDTolNul, ThreeDTol,
178                                      FirstS, LastS, Order,
179                                      MaxDegree, MaxSegments,
180                                      evC, CutTool);
181
182 #ifdef OCCT_DEBUG_CHRONO
183   ResultChron(chr_approx, t_approx);
184 #endif
185
186   myDone      = aApprox.IsDone();
187   myHasResult = aApprox.HasResult();
188
189   if (myHasResult) {
190     TColgp_Array1OfPnt Poles(1,aApprox.NbPoles());
191     aApprox.Poles(1,Poles);
192     Handle(TColStd_HArray1OfReal)    Knots = aApprox.Knots();
193     Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
194     Standard_Integer Degree = aApprox.Degree();
195     myCurve3d = new Geom_BSplineCurve(Poles, Knots->Array1(), Mults->Array1(), Degree);
196   }
197   myMaxError3d = aApprox.MaxError(3,1);
198
199 #ifdef OCCT_DEBUG_CHRONO
200   ResultChron(chr_total, t_total);
201
202   std::cout<<" total reparametrization time = "<<t_total<<std::endl;
203   std::cout<<"initialization time = "<<t_init<<std::endl;
204   std::cout<<"approximation time = "<<t_approx<<std::endl;
205   std::cout<<"total time for uparam computation = "<<t_uparam<<std::endl;
206   std::cout<<"number uparam calles = "<<uparam_count<<std::endl;
207 #endif
208 }
209
210 //=======================================================================
211 //class : Approx_CurvilinearParameter_EvalCurvOnSurf
212 //purpose  : case of a curve on one surface
213 //=======================================================================
214
215 class Approx_CurvilinearParameter_EvalCurvOnSurf : public AdvApprox_EvaluatorFunction
216 {
217  public:
218   Approx_CurvilinearParameter_EvalCurvOnSurf (const Handle(Approx_CurvlinFunc)& theFunc, 
219                                               Standard_Real First, Standard_Real Last)
220     : fonct(theFunc) { StartEndSav[0] = First; StartEndSav[1] = Last; }
221   
222   virtual void Evaluate (Standard_Integer *Dimension,
223                          Standard_Real     StartEnd[2],
224                          Standard_Real    *Parameter,
225                          Standard_Integer *DerivativeRequest,
226                          Standard_Real    *Result, // [Dimension]
227                          Standard_Integer *ErrorCode);
228   
229  private:
230   Handle(Approx_CurvlinFunc) fonct;
231   Standard_Real StartEndSav[2];
232 };
233
234 void Approx_CurvilinearParameter_EvalCurvOnSurf::Evaluate (Standard_Integer * Dimension,
235                                                            Standard_Real    * StartEnd,
236                                                            Standard_Real    * Param,
237                                                            Standard_Integer * Order,
238                                                            Standard_Real    * Result,
239                                                            Standard_Integer * ErrorCode)
240 {
241   *ErrorCode = 0;
242   Standard_Real S = *Param;
243   TColStd_Array1OfReal Res(0, 4);
244   Standard_Integer i;
245
246 // Dimension is incorrect
247   if (*Dimension != 5) {
248     *ErrorCode = 1;
249   }
250 // Parameter is incorrect
251   if ( S < StartEnd[0] || S > StartEnd[1] ) {
252     *ErrorCode = 2;
253   }
254
255   if(StartEnd[0] != StartEndSav[0] || StartEnd[1]!= StartEndSav[1]) 
256     {
257       fonct->Trim(StartEnd[0],StartEnd[1], Precision::Confusion());
258       StartEndSav[0]=StartEnd[0];
259       StartEndSav[1]=StartEnd[1];
260     }
261
262   if(!fonct->EvalCase2(S, *Order, Res)) {
263     *ErrorCode = 3;
264   }
265
266   for(i = 0; i <= 4; i++)
267     Result[i] = Res(i);  
268 }
269
270 Approx_CurvilinearParameter::Approx_CurvilinearParameter(const Handle(Adaptor2d_HCurve2d)& C2D,
271                                                          const Handle(Adaptor3d_HSurface)& Surf,
272                                                          const Standard_Real Tol,
273                                                          const GeomAbs_Shape Order,
274                                                          const Standard_Integer MaxDegree,
275                                                          const Standard_Integer MaxSegments)
276 {
277 #ifdef OCCT_DEBUG_CHRONO
278   t_total = t_init = t_approx = t_uparam = 0;
279   uparam_count = 0;
280   InitChron(chr_total);
281 #endif
282   myCase = 2;
283
284   // Initialisation of input parameters of AdvApprox
285
286   Standard_Integer Num1DSS=2, Num2DSS=0, Num3DSS=1, i;
287
288   Handle(TColStd_HArray1OfReal) OneDTol = new TColStd_HArray1OfReal(1,Num1DSS);
289   Standard_Real TolV,TolW;
290
291   ToleranceComputation(C2D,Surf,10,Tol,TolV,TolW);
292   OneDTol->SetValue(1,TolV);
293   OneDTol->SetValue(2,TolW);
294
295   OneDTol->SetValue(1,Tol);
296   OneDTol->SetValue(2,Tol);
297
298   Handle(TColStd_HArray1OfReal) TwoDTolNul; 
299   Handle(TColStd_HArray1OfReal) ThreeDTol = new TColStd_HArray1OfReal(1,Num3DSS);
300   ThreeDTol->Init(Tol/2.); 
301
302 #ifdef OCCT_DEBUG_CHRONO
303   InitChron(chr_init);
304 #endif
305   Handle(Approx_CurvlinFunc) fonct = new Approx_CurvlinFunc(C2D, Surf, Tol/20);
306 #ifdef OCCT_DEBUG_CHRONO
307   ResultChron(chr_init, t_init);
308 #endif
309
310   Standard_Real FirstS = fonct->FirstParameter();
311   Standard_Real  LastS = fonct->LastParameter();
312
313   Standard_Integer NbInterv_C2 = fonct->NbIntervals(GeomAbs_C2);
314   TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2+1);
315   fonct->Intervals(CutPnts_C2,GeomAbs_C2);
316   Standard_Integer NbInterv_C3 = fonct->NbIntervals(GeomAbs_C3);
317   TColStd_Array1OfReal CutPnts_C3(1, NbInterv_C3+1);
318   fonct->Intervals(CutPnts_C3,GeomAbs_C3);
319   AdvApprox_PrefAndRec CutTool(CutPnts_C2,CutPnts_C3);
320
321 #ifdef OCCT_DEBUG_CHRONO
322   InitChron(chr_approx);
323 #endif
324
325   Approx_CurvilinearParameter_EvalCurvOnSurf evCOnS (fonct, FirstS, LastS);
326   AdvApprox_ApproxAFunction aApprox (Num1DSS, Num2DSS, Num3DSS, 
327                                      OneDTol, TwoDTolNul, ThreeDTol,
328                                      FirstS, LastS, Order,
329                                      MaxDegree, MaxSegments,
330                                      evCOnS, CutTool);
331
332 #ifdef OCCT_DEBUG_CHRONO
333   ResultChron(chr_approx, t_approx);
334 #endif
335
336   myDone      = aApprox.IsDone();
337   myHasResult = aApprox.HasResult();
338
339   if (myHasResult) {
340     Standard_Integer NbPoles = aApprox.NbPoles();
341     TColgp_Array1OfPnt   Poles  (1,NbPoles);
342     TColgp_Array1OfPnt2d Poles2d(1,NbPoles);
343     TColStd_Array1OfReal Poles1d(1,NbPoles);
344     aApprox.Poles(1,Poles);
345     aApprox.Poles1d(1,Poles1d);
346     for (i=1; i<=NbPoles; i++) 
347       Poles2d(i).SetX(Poles1d(i));
348     aApprox.Poles1d(2,Poles1d);
349     for (i=1; i<=NbPoles; i++) 
350       Poles2d(i).SetY(Poles1d(i));
351     Handle(TColStd_HArray1OfReal)    Knots = aApprox.Knots();
352     Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
353     Standard_Integer Degree = aApprox.Degree();
354     myCurve3d = new Geom_BSplineCurve(Poles, Knots->Array1(), Mults->Array1(), Degree);
355     myCurve2d1 = new Geom2d_BSplineCurve(Poles2d, Knots->Array1(), Mults->Array1(), Degree);
356   }
357   myMaxError2d1 = Max (aApprox.MaxError(1,1),aApprox.MaxError(1,2));
358   myMaxError3d  = aApprox.MaxError(3,1);
359
360 #ifdef OCCT_DEBUG_CHRONO
361   ResultChron(chr_total, t_total);
362
363   std::cout<<" total reparametrization time = "<<t_total<<std::endl;
364   std::cout<<"initialization time = "<<t_init<<std::endl;
365   std::cout<<"approximation time = "<<t_approx<<std::endl;
366   std::cout<<"total time for uparam computation = "<<t_uparam<<std::endl;
367   std::cout<<"number uparam calles = "<<uparam_count<<std::endl;
368 #endif
369 }
370
371 //=======================================================================
372 //function : Approx_CurvilinearParameter_EvalCurvOn2Surf
373 //purpose  : case of a curve on two surfaces
374 //=======================================================================
375
376 class Approx_CurvilinearParameter_EvalCurvOn2Surf : public AdvApprox_EvaluatorFunction
377 {
378  public:
379   Approx_CurvilinearParameter_EvalCurvOn2Surf (const Handle(Approx_CurvlinFunc)& theFunc, 
380                                                Standard_Real First, Standard_Real Last)
381     : fonct(theFunc) { StartEndSav[0] = First; StartEndSav[1] = Last; }
382   
383   virtual void Evaluate (Standard_Integer *Dimension,
384                          Standard_Real     StartEnd[2],
385                          Standard_Real    *Parameter,
386                          Standard_Integer *DerivativeRequest,
387                          Standard_Real    *Result, // [Dimension]
388                          Standard_Integer *ErrorCode);
389   
390  private:
391   Handle(Approx_CurvlinFunc) fonct;
392   Standard_Real StartEndSav[2];
393 };
394
395 void Approx_CurvilinearParameter_EvalCurvOn2Surf::Evaluate (Standard_Integer * Dimension,
396                                                             Standard_Real    * StartEnd,
397                                                             Standard_Real    * Param,
398                                                             Standard_Integer * Order,
399                                                             Standard_Real    * Result,
400                                                             Standard_Integer * ErrorCode)
401 {
402   *ErrorCode = 0;
403   Standard_Real S = *Param;
404   TColStd_Array1OfReal Res(0, 6);
405   Standard_Integer i;
406
407 // Dimension is incorrect
408   if (*Dimension != 7) {
409     *ErrorCode = 1;
410   }
411 // Parameter is incorrect
412   if ( S < StartEnd[0] || S > StartEnd[1] ) {
413     *ErrorCode = 2;
414   }
415
416 /*  if(StartEnd[0] != StartEndSav[0] || StartEnd[1]!= StartEndSav[1]) 
417     {
418       fonct->Trim(StartEnd[0],StartEnd[1], Precision::Confusion());
419       StartEndSav[0]=StartEnd[0];
420       StartEndSav[1]=StartEnd[1];
421     }
422 */
423   if(!fonct->EvalCase3(S, *Order, Res)) {
424     *ErrorCode = 3;
425   }
426
427   for(i = 0; i <= 6; i++)
428     Result[i] = Res(i);  
429 }
430
431 Approx_CurvilinearParameter::Approx_CurvilinearParameter(const Handle(Adaptor2d_HCurve2d)& C2D1,
432                                                          const Handle(Adaptor3d_HSurface)& Surf1,
433                                                          const Handle(Adaptor2d_HCurve2d)& C2D2,
434                                                          const Handle(Adaptor3d_HSurface)& Surf2,
435                                                          const Standard_Real Tol,
436                                                          const GeomAbs_Shape Order,
437                                                          const Standard_Integer MaxDegree,
438                                                          const Standard_Integer MaxSegments)
439 {
440   Standard_Integer i;
441
442 #ifdef OCCT_DEBUG_CHRONO
443   t_total = t_init = t_approx = t_uparam = 0;
444   uparam_count = 0;
445   InitChron(chr_total);
446 #endif
447   myCase = 3;
448
449   // Initialisation of input parameters of AdvApprox
450
451   Standard_Integer Num1DSS=4, Num2DSS=0, Num3DSS=1;
452   Handle(TColStd_HArray1OfReal) OneDTol = new TColStd_HArray1OfReal(1,Num1DSS); 
453
454   Standard_Real TolV,TolW;
455   ToleranceComputation(C2D1,Surf1,10,Tol,TolV,TolW);
456   OneDTol->SetValue(1,TolV); 
457   OneDTol->SetValue(2,TolW); 
458   
459   ToleranceComputation(C2D2,Surf2,10,Tol,TolV,TolW);
460   OneDTol->SetValue(3,TolV); 
461   OneDTol->SetValue(4,TolW); 
462
463   Handle(TColStd_HArray1OfReal) TwoDTolNul; 
464   Handle(TColStd_HArray1OfReal) ThreeDTol = new TColStd_HArray1OfReal(1,Num3DSS);
465   ThreeDTol->Init(Tol/2); 
466
467 #ifdef OCCT_DEBUG_CHRONO
468   InitChron(chr_init);
469 #endif
470   Handle(Approx_CurvlinFunc) fonct = new Approx_CurvlinFunc(C2D1, C2D2, Surf1, Surf2, Tol/20);
471 #ifdef OCCT_DEBUG_CHRONO
472   ResultChron(chr_init, t_init);
473 #endif
474
475   Standard_Real FirstS = fonct->FirstParameter();
476   Standard_Real  LastS = fonct->LastParameter();
477
478   Standard_Integer NbInterv_C2 = fonct->NbIntervals(GeomAbs_C2);
479   TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2+1);
480   fonct->Intervals(CutPnts_C2,GeomAbs_C2);
481   Standard_Integer NbInterv_C3 = fonct->NbIntervals(GeomAbs_C3);
482   TColStd_Array1OfReal CutPnts_C3(1, NbInterv_C3+1);
483   fonct->Intervals(CutPnts_C3,GeomAbs_C3);
484   AdvApprox_PrefAndRec CutTool(CutPnts_C2,CutPnts_C3);  
485
486 #ifdef OCCT_DEBUG_CHRONO
487   InitChron(chr_approx);
488 #endif
489
490   Approx_CurvilinearParameter_EvalCurvOn2Surf evCOn2S (fonct, FirstS, LastS);
491   AdvApprox_ApproxAFunction aApprox (Num1DSS, Num2DSS, Num3DSS, 
492                                      OneDTol, TwoDTolNul, ThreeDTol,
493                                      FirstS, LastS, Order,
494                                      MaxDegree, MaxSegments,
495                                      evCOn2S, CutTool);
496
497 #ifdef OCCT_DEBUG_CHRONO
498   ResultChron(chr_approx, t_approx);
499 #endif
500
501   myDone      = aApprox.IsDone();
502   myHasResult = aApprox.HasResult();
503
504   if (myHasResult) {
505     Standard_Integer NbPoles = aApprox.NbPoles();
506     TColgp_Array1OfPnt   Poles  (1,NbPoles);
507     TColgp_Array1OfPnt2d Poles2d(1,NbPoles);
508     TColStd_Array1OfReal Poles1d(1,NbPoles);
509     aApprox.Poles(1,Poles);
510     aApprox.Poles1d(1,Poles1d);
511     for (i=1; i<=NbPoles; i++) 
512       Poles2d(i).SetX(Poles1d(i));
513     aApprox.Poles1d(2,Poles1d);
514     for (i=1; i<=NbPoles; i++) 
515       Poles2d(i).SetY(Poles1d(i));
516     Handle(TColStd_HArray1OfReal)    Knots = aApprox.Knots();
517     Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
518     Standard_Integer Degree = aApprox.Degree();
519     myCurve3d = new Geom_BSplineCurve(Poles, Knots->Array1(), Mults->Array1(), Degree);
520     myCurve2d1 = new Geom2d_BSplineCurve(Poles2d, Knots->Array1(), Mults->Array1(), Degree);
521     aApprox.Poles1d(3,Poles1d);
522     for (i=1; i<=NbPoles; i++) 
523       Poles2d(i).SetX(Poles1d(i));
524     aApprox.Poles1d(4,Poles1d);
525     for (i=1; i<=NbPoles; i++) 
526       Poles2d(i).SetY(Poles1d(i));
527     myCurve2d2 = new Geom2d_BSplineCurve(Poles2d, Knots->Array1(), Mults->Array1(), Degree);
528   }
529   myMaxError2d1 = Max (aApprox.MaxError(1,1),aApprox.MaxError(1,2));
530   myMaxError2d2 = Max (aApprox.MaxError(1,3),aApprox.MaxError(1,4));
531   myMaxError3d  = aApprox.MaxError(3,1);
532
533 #ifdef OCCT_DEBUG_CHRONO
534   ResultChron(chr_total, t_total);
535
536   std::cout<<" total reparametrization time = "<<t_total<<std::endl;
537   std::cout<<"initialization time = "<<t_init<<std::endl;
538   std::cout<<"approximation time = "<<t_approx<<std::endl;
539   std::cout<<"total time for uparam computation = "<<t_uparam<<std::endl;
540   std::cout<<"number uparam calles = "<<uparam_count<<std::endl;
541 #endif
542 }
543
544 //=======================================================================
545 //function : IsDone
546 //purpose  : 
547 //=======================================================================
548
549  Standard_Boolean Approx_CurvilinearParameter::IsDone() const
550 {
551   return myDone;
552 }
553
554 //=======================================================================
555 //function : HasResult
556 //purpose  : 
557 //=======================================================================
558
559  Standard_Boolean Approx_CurvilinearParameter::HasResult() const
560 {
561   return myHasResult;
562 }
563
564 //=======================================================================
565 //function : Curve3d
566 //purpose  : returns the Bspline curve corresponding to the reparametrized 3D curve 
567 //=======================================================================
568
569  Handle(Geom_BSplineCurve) Approx_CurvilinearParameter::Curve3d() const
570 {
571   return myCurve3d;
572 }
573
574 //=======================================================================
575 //function : MaxError3d
576 //purpose  : returns the maximum error on the reparametrized 3D curve
577 //=======================================================================
578
579  Standard_Real Approx_CurvilinearParameter::MaxError3d() const
580 {
581   return myMaxError3d;
582 }
583
584 //=======================================================================
585 //function : Curve2d1
586 //purpose  : returns the BsplineCurve representing the reparametrized 2D curve on the
587 //           first surface (case of a curve on one or two surfaces)
588 //=======================================================================
589
590  Handle(Geom2d_BSplineCurve) Approx_CurvilinearParameter::Curve2d1() const
591 {
592   return myCurve2d1;
593 }
594
595 //=======================================================================
596 //function : MaxError2d1
597 //purpose  : returns the maximum error on the first reparametrized 2D curve
598 //=======================================================================
599
600  Standard_Real Approx_CurvilinearParameter::MaxError2d1() const
601 {
602   return myMaxError2d1;
603 }
604
605 //=======================================================================
606 //function : Curve2d2
607 //purpose  : returns the BsplineCurve representing the reparametrized 2D curve on the
608 //           second surface (case of a curve on two surfaces)
609 //=======================================================================
610
611  Handle(Geom2d_BSplineCurve) Approx_CurvilinearParameter::Curve2d2() const
612 {
613   return myCurve2d2;
614 }
615
616 //=======================================================================
617 //function : MaxError2d2
618 //purpose  : returns the maximum error on the second reparametrized 2D curve 
619 //=======================================================================
620
621  Standard_Real Approx_CurvilinearParameter::MaxError2d2() const
622 {
623   return myMaxError2d2;
624 }
625
626 //=======================================================================
627 //function : Dump
628 //purpose  : print the maximum errors(s)
629 //=======================================================================
630
631 void Approx_CurvilinearParameter::Dump(Standard_OStream& o) const
632 {
633   o << "Dump of Approx_CurvilinearParameter" << std::endl;
634   if (myCase==2 || myCase==3) 
635     o << "myMaxError2d1 = " << myMaxError2d1 << std::endl;
636   if (myCase==3) 
637     o << "myMaxError2d2 = " << myMaxError2d2 << std::endl;
638   o << "myMaxError3d = " << myMaxError3d << std::endl;
639 }
640
641 //=======================================================================
642 //function : ToleranceComputation
643 //purpose  : 
644 //=======================================================================
645
646 void Approx_CurvilinearParameter::ToleranceComputation(const Handle(Adaptor2d_HCurve2d) &C2D,
647                                                        const Handle(Adaptor3d_HSurface) &S, 
648                                                        const Standard_Integer MaxNumber, 
649                                                        const Standard_Real Tol,
650                                                        Standard_Real &TolV, Standard_Real &TolW)
651 {
652   Standard_Real FirstU = C2D->FirstParameter(),
653                 LastU  = C2D->LastParameter();
654 //  Standard_Real parU, Max_dS_dv=1.,Max_dS_dw=1.;
655   Standard_Real Max_dS_dv=1.,Max_dS_dw=1.;
656   gp_Pnt P;
657   gp_Pnt2d pntVW;
658   gp_Vec dS_dv,dS_dw;
659
660   for (Standard_Integer i=1; i<=MaxNumber; i++) {
661     pntVW = C2D->Value(FirstU + (i-1)*(LastU-FirstU)/(MaxNumber-1));
662     S->D1(pntVW.X(),pntVW.Y(),P,dS_dv,dS_dw);
663     Max_dS_dv = Max (Max_dS_dv, dS_dv.Magnitude());
664     Max_dS_dw = Max (Max_dS_dw, dS_dw.Magnitude());
665   }
666   TolV = Tol / (4.*Max_dS_dv);
667   TolW = Tol / (4.*Max_dS_dw);
668
669 #ifdef OCCT_DEBUG
670   std::cout << "TolV = " << TolV << std::endl;
671   std::cout << "TolW = " << TolW << std::endl;
672 #endif
673 }