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