6faac3b7cec0449fe68a8ed6ac75651b200f4218
[occt.git] / src / Approx / Approx_ComputeCLine.gxx
1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 //  modified by Edward AGAPOV (eap) Tue Apr 2 2002 (occ265)
16 //  -- stop cutting an interval to approximate if next decisions
17 //  -- get worse on and on
18
19
20
21 #include <Approx_ParametrizationType.hxx>
22 #include <AppCont_LeastSquare.hxx>
23 #include <TColStd_Array1OfReal.hxx>
24 #include <AppParCurves_Constraint.hxx>
25 #include <Approx_Status.hxx>
26 #include <Precision.hxx>
27
28 //=======================================================================
29 //function : Approx_ComputeCLine
30 //purpose  : The MultiLine <Line> will be approximated until tolerances
31 //           will be reached.
32 //           The approximation will be done from degreemin to degreemax
33 //           with a cutting if the corresponding boolean is True.
34 //=======================================================================
35
36 Approx_ComputeCLine::Approx_ComputeCLine
37                     (const MultiLine& Line,
38                      const Standard_Integer degreemin,
39                      const Standard_Integer degreemax,
40                      const Standard_Real Tolerance3d,
41                      const Standard_Real Tolerance2d,
42                      const Standard_Boolean cutting,
43                      const AppParCurves_Constraint FirstC,
44                      const AppParCurves_Constraint LastC)
45 {
46   mydegremin = degreemin;
47   mydegremax = degreemax;
48   mytol3d = Tolerance3d;
49   mytol2d = Tolerance2d;
50   mycut = cutting;
51   myfirstC = FirstC;
52   mylastC = LastC;
53   alldone = Standard_False;
54   Perform(Line);
55 }
56
57 //=======================================================================
58 //function : Approx_ComputeCLine
59 //purpose  : Initializes the fields of the algorithm.
60 //=======================================================================
61
62 Approx_ComputeCLine::Approx_ComputeCLine
63                     (const Standard_Integer degreemin,
64                      const Standard_Integer degreemax,
65                      const Standard_Real Tolerance3d,
66                      const Standard_Real Tolerance2d,
67                      const Standard_Boolean cutting,
68                      const AppParCurves_Constraint FirstC,
69                      const AppParCurves_Constraint LastC)
70 {
71   alldone = Standard_False;
72   mydegremin = degreemin;
73   mydegremax = degreemax;
74   mytol3d = Tolerance3d;
75   mytol2d = Tolerance2d;
76   mycut = cutting;
77   myfirstC = FirstC;
78   mylastC = LastC;
79 }
80
81 //=======================================================================
82 //function : Perform
83 //purpose  : runs the algorithm after having initialized the fields.
84 //=======================================================================
85
86 void Approx_ComputeCLine::Perform(const MultiLine& Line)
87 {
88   Standard_Real UFirst, ULast;
89   Standard_Boolean Finish = Standard_False, 
90           begin = Standard_True, Ok = Standard_False;
91   Standard_Real thetol3d = Precision::Confusion(), thetol2d = Precision::Confusion();
92   UFirst = Line.FirstParameter();
93   ULast  = Line.LastParameter();
94   Standard_Real TolU = (ULast-UFirst)*1.e-05;
95   Standard_Real myfirstU = UFirst; 
96   Standard_Real mylastU = ULast;
97
98   if (!mycut)
99   {
100     alldone = Compute(Line, UFirst, ULast, thetol3d, thetol2d);
101     if (!alldone) 
102     {
103       tolreached = Standard_False;
104       myfirstparam.Append(UFirst);
105       mylastparam.Append(ULast);
106       myMultiCurves.Append(TheMultiCurve);
107       Tolers3d.Append(currenttol3d);
108       Tolers2d.Append(currenttol2d);
109     }
110   }
111   else 
112   {
113
114     // previous decision to be taken if we get worse with next cut (eap)
115     AppParCurves_MultiCurve KeptMultiCurve;
116     Standard_Real KeptUfirst = 0., KeptUlast = 0., KeptT3d = RealLast(), KeptT2d = 0.;
117
118     while (!Finish) 
119     {
120       
121       // Gestion du decoupage de la multiline pour approximer:
122       if (!begin) 
123       {
124         if (Ok) 
125         {
126           // Calcul de la partie a approximer.
127           myfirstU = mylastU;
128           mylastU  = ULast;
129           if (Abs(ULast-myfirstU) <= RealEpsilon())
130           {
131             Finish = Standard_True;
132             alldone = Standard_True;
133             return;
134           }
135           KeptT3d = RealLast(); KeptT2d = 0;
136           KeptUfirst = myfirstU;
137           KeptUlast = mylastU;
138         }
139         else
140         {
141           // keep best decison
142           if ((thetol3d + thetol2d) < (KeptT3d + KeptT2d))
143           {
144             KeptMultiCurve = TheMultiCurve;
145             KeptUfirst     = myfirstU;
146             KeptUlast      = mylastU;
147             KeptT3d        = thetol3d;
148             KeptT2d        = thetol2d;
149           }
150
151           // cut an interval
152           mylastU = (myfirstU + mylastU)/2;
153         }
154       }
155
156       // Calcul des parametres sur ce nouvel intervalle.
157       Ok = Compute(Line, myfirstU, mylastU, thetol3d, thetol2d);
158
159       //cout << myfirstU << " - " << mylastU << "  tol : " << thetol3d << " " << thetol2d << endl;
160
161       // is new decision better?
162       if (!Ok && Abs(myfirstU-mylastU) <= TolU)
163       {
164           Ok = Standard_True; // stop interval cutting, approx the rest part
165           mylastU = KeptUlast;
166
167           tolreached = Standard_False; // helas
168           myMultiCurves.Append(KeptMultiCurve);
169           Tolers3d.Append     (KeptT3d);
170           Tolers2d.Append     (KeptT2d);
171           myfirstparam.Append (KeptUfirst);
172           mylastparam.Append  (KeptUlast);
173         }
174
175       begin = Standard_False;
176     } // while (!Finish)
177   }
178 }
179
180 //=======================================================================
181 //function : NbMultiCurves
182 //purpose  : Returns the number of MultiCurve doing the approximation
183 //           of the MultiLine.
184 //=======================================================================
185
186 Standard_Integer Approx_ComputeCLine::NbMultiCurves()const
187 {
188   return myMultiCurves.Length();
189 }
190
191 //=======================================================================
192 //function : Value
193 //purpose  : returns the approximation MultiCurve of range <Index>.
194 //=======================================================================
195
196 AppParCurves_MultiCurve Approx_ComputeCLine::Value(const Standard_Integer Index)
197 const
198 {
199   return myMultiCurves.Value(Index);
200 }
201
202 //=======================================================================
203 //function : Compute
204 //purpose  : is internally used by the algorithms.
205 //=======================================================================
206
207 Standard_Boolean Approx_ComputeCLine::Compute(const MultiLine& Line,
208                                              const Standard_Real Ufirst,
209                                              const Standard_Real Ulast,
210                                              Standard_Real&   TheTol3d,
211                                              Standard_Real&   TheTol2d)
212 {
213
214
215   Standard_Integer deg, NbPoints = 24;
216   Standard_Boolean mydone;
217   Standard_Real Fv;
218
219   for (deg = mydegremin; deg <= mydegremax; deg++) {
220
221     AppParCurves_MultiCurve mySCU(deg+1);
222     AppCont_LeastSquare LSquare(Line, Ufirst, Ulast, myfirstC, mylastC, deg, NbPoints);
223     mydone = LSquare.IsDone();
224     if (mydone) {
225       LSquare.Error(Fv, TheTol3d, TheTol2d);
226       if (TheTol3d <= mytol3d && TheTol2d <= mytol2d) {
227         mySCU = LSquare.Value();
228         // Stockage de la multicurve approximee.
229         tolreached = Standard_True;
230         myMultiCurves.Append(mySCU);
231         myfirstparam.Append(Ufirst);
232         mylastparam.Append(Ulast);
233         Tolers3d.Append(TheTol3d);
234         Tolers2d.Append(TheTol2d);
235         return Standard_True;
236       }
237     }
238     if (deg == mydegremax) {
239       TheMultiCurve = LSquare.Value();
240       currenttol3d = TheTol3d;
241       currenttol2d = TheTol2d;
242     }
243     
244   }
245   return Standard_False;
246 }
247
248 //=======================================================================
249 //function : Parameters
250 //purpose  : returns the first and last parameters of the 
251 //           <Index> MultiCurve.
252 //=======================================================================
253
254 void Approx_ComputeCLine::Parameters(const Standard_Integer Index,
255                                      Standard_Real& firstpar,
256                                      Standard_Real& lastpar) const
257 {
258   firstpar = myfirstparam.Value(Index);
259   lastpar  = mylastparam.Value(Index);
260 }
261
262 //=======================================================================
263 //function : SetDegrees
264 //purpose  : changes the degrees of the approximation.
265 //=======================================================================
266
267 void Approx_ComputeCLine::SetDegrees(const Standard_Integer degreemin,
268                                      const Standard_Integer degreemax)
269 {
270   mydegremin = degreemin;
271   mydegremax = degreemax;
272 }
273
274 //=======================================================================
275 //function : SetTolerances
276 //purpose  : Changes the tolerances of the approximation.
277 //=======================================================================
278
279 void Approx_ComputeCLine::SetTolerances(const Standard_Real Tolerance3d,
280                                        const Standard_Real Tolerance2d)
281 {
282   mytol3d = Tolerance3d;
283   mytol2d = Tolerance2d;
284 }
285
286 //=======================================================================
287 //function : SetConstraints
288 //purpose  : Changes the constraints of the approximation.
289 //=======================================================================
290
291 void Approx_ComputeCLine::SetConstraints(const AppParCurves_Constraint FirstC,
292                                          const AppParCurves_Constraint LastC)
293 {
294   myfirstC = FirstC;
295   mylastC  = LastC;
296 }
297
298 //=======================================================================
299 //function : IsAllApproximated
300 //purpose  : returns False if at a moment of the approximation,
301 //           the status NoApproximation has been sent by the user
302 //           when more points were needed.
303 //=======================================================================
304
305 Standard_Boolean Approx_ComputeCLine::IsAllApproximated()
306 const {
307   return alldone;
308 }
309
310 //=======================================================================
311 //function : IsToleranceReached
312 //purpose  : returns False if the status NoPointsAdded has been sent.
313 //=======================================================================
314
315 Standard_Boolean Approx_ComputeCLine::IsToleranceReached()
316 const {
317   return tolreached;
318 }
319
320 //=======================================================================
321 //function : Error
322 //purpose  : returns the tolerances 2d and 3d of the <Index> MultiCurve.
323 //=======================================================================
324
325 void Approx_ComputeCLine::Error(const Standard_Integer Index,
326                                Standard_Real& tol3d,
327                                Standard_Real& tol2d) const
328 {
329   tol3d = Tolers3d.Value(Index);
330   tol2d = Tolers2d.Value(Index);
331 }