0031668: Visualization - WebGL sample doesn't work on Emscripten 1.39
[occt.git] / src / CPnts / CPnts_UniformDeflection.cxx
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 //-------------------------------------------------------------------
16 //                Algorithm concerns the constant arrow
17 // cases processed : parameterized curve 
18 //               the curve should be C2
19 // provide a max arrow
20 // algorithm of parameterized curve:
21 //   calculation of the step of advancement is 
22 //             du = sqrt(8*fleche*||P'(u)||/||P'(u)^P''(u)||
23 //   calculate each point such as u+Du
24 //   check if the arrow is actually taken into account, if yes, continue
25 //   otherwise correct the step
26 //   si du cannot be calculated (null curvature, singularity on the curve) 
27 //   take a constant step to reach the last point or to go past it
28 //   The last point is readjusted by the following criteria:
29 //     if the last calculated parameter is <2*resolution, reframe the last point found
30 //     between itself and the previous point and add the end point 
31 //     (avoid a concentration at the end)
32 //     otherwise if the distance (last calculated point, end point)<arrow, 
33 //     replace the last calculated point by the end point
34 //     otherwise calculate max arrow between the last but one calculated point
35 //     and the end point; if this arrow is greater than the arrow
36 //     replace the last point by this one and the end point
37 //    CONTROLS OF ARROW AND THE LAST POINT ARE DONE ONLY IF withControl=true
38 //   each iteration calculates at maximum 3 points
39 //-------------------------------------------------------------------------
40
41 #include <Adaptor2d_Curve2d.hxx>
42 #include <Adaptor3d_Curve.hxx>
43 #include <CPnts_UniformDeflection.hxx>
44 #include <gp_Pnt.hxx>
45 #include <gp_Pnt2d.hxx>
46 #include <gp_Vec.hxx>
47 #include <gp_Vec2d.hxx>
48 #include <Standard_ConstructionError.hxx>
49 #include <Standard_DomainError.hxx>
50 #include <Standard_OutOfRange.hxx>
51 #include <StdFail_NotDone.hxx>
52
53 static inline void D03d(const Standard_Address C, const Standard_Real U,
54                       gp_Pnt& P)
55 {
56   ((Adaptor3d_Curve*)C)->D0(U,P);
57 }
58
59 static  void D02d(const Standard_Address C, const Standard_Real U,
60                       gp_Pnt& PP)
61 {
62   gp_Pnt2d P;
63   ((Adaptor2d_Curve2d*)C)->D0(U,P);
64   PP.SetCoord(P.X(),P.Y(),0.);
65 }
66
67 static inline void D23d(const Standard_Address C, const Standard_Real U,
68                       gp_Pnt& P, gp_Vec& V1, gp_Vec& V2)
69 {
70   ((Adaptor3d_Curve*)C)->D2(U,P,V1,V2);
71 }
72
73 static  void D22d(const Standard_Address C, const Standard_Real U,
74                       gp_Pnt& PP, gp_Vec& VV1, gp_Vec& VV2)
75 {
76   gp_Pnt2d P;
77   gp_Vec2d V1,V2;
78   ((Adaptor2d_Curve2d*)C)->D2(U,P,V1,V2);
79   PP.SetCoord(P.X(),P.Y(),0.);
80   VV1.SetCoord(V1.X(),V1.Y(),0.);
81   VV2.SetCoord(V2.X(),V2.Y(),0.);
82 }
83
84 //=======================================================================
85 //function : Perform
86 //purpose  : 
87 //=======================================================================
88
89 void CPnts_UniformDeflection::Perform()
90 {
91   gp_Pnt P, P1, P2;
92 //  gp_Vec V1, V2, VV1, VV2, VV;
93   gp_Vec V1, V2, VV;
94   Standard_Real Un1; 
95   Standard_Real NormD1, NormD2;
96
97   myIPoint   = -1;
98   myNbPoints = -1;
99   
100   while ( (myNbPoints<2) && (!myFinish) ) {
101     
102     myNbPoints = myNbPoints + 1; 
103     myParams[myNbPoints] = myFirstParam;
104
105     if (my3d)
106       D23d(myCurve, myFirstParam, myPoints[myNbPoints], V1, V2);
107     else
108       D22d(myCurve, myFirstParam, myPoints[myNbPoints], V1, V2);
109     P = myPoints[myNbPoints] ;
110     NormD1 = V1.Magnitude();
111     if (NormD1 < myTolCur || V2.Magnitude() < myTolCur) {   
112       // singularity on the tangent or null curvature
113       myDu = Min(myDwmax, 1.5 * myDu);
114     }
115     else { 
116       NormD2 = V2.CrossMagnitude(V1);
117       if (NormD2 / NormD1 < myDeflection) {  // collinearity of derivatives
118         myDu = Min(myDwmax, 1.5 * myDu);            
119       }
120       else {
121         myDu = Sqrt(8.* myDeflection * NormD1 / NormD2 );
122         myDu = Min(Max(myDu, myTolCur), myDwmax);             
123       }
124     }
125     
126     // check if the arrow is observed if WithControl
127     
128     if (myControl) {
129       myDu = Min(myDu, myLastParam-myFirstParam);
130       if (my3d) {
131         
132         D03d(myCurve, myFirstParam + myDu,P);
133         D03d(myCurve, myFirstParam + (myDu / 2.0),P1);
134       }
135       else {
136         
137         D02d(myCurve, myFirstParam + myDu,P);
138         D02d(myCurve, myFirstParam + (myDu / 2.0),P1);
139       }
140       V1= gp_Vec(myPoints[myNbPoints], P);
141       NormD1 = V1.Magnitude(); 
142       if (NormD1 >= myDeflection) {
143         V2 = gp_Vec(myPoints[myNbPoints], P1);
144         NormD2 = V2.CrossMagnitude(V1) / NormD1;
145         
146         // passing of arrow starting from which the redivision is done is arbitrary
147         // probably it will be necessary to readjust it (differenciate the first point 
148         // from the others) this test does not work on the points of inflexion
149         
150         if (NormD2 > myDeflection / 5.0) {
151           NormD2 = Max(NormD2, 1.1 * myDeflection);
152           myDu = myDu * Sqrt(myDeflection / NormD2);
153           myDu = Min(Max(myDu, myTolCur), myDwmax);             
154         }
155       }
156     }
157     myFirstParam = myFirstParam + myDu;
158     myFinish = (myLastParam - myFirstParam < myTolCur) || (myDu == 0.);
159   }
160   if (myFinish) {
161     // the last point is corrected if control
162     if (myControl && (myNbPoints == 1) ) {
163       Un1 = myParams[0];
164       if (myLastParam - Un1 < 0.33*(myLastParam-myFirstParam)) {
165         myFirstParam = (myLastParam + Un1) / 2.0;
166         myParams[0]= myFirstParam;
167         myParams[1]= myLastParam;
168         if (my3d) {
169           D03d(myCurve, myParams[0], myPoints[0]);
170           D03d(myCurve, myParams[1], myPoints[1]);
171         }
172         else {
173           D02d(myCurve, myParams[0], myPoints[0]);
174           D02d(myCurve, myParams[1], myPoints[1]);
175         }
176       } 
177       else {
178         if (my3d) {
179           D23d(myCurve, myLastParam, P1, V1, V2);
180         }
181         else {
182           D22d(myCurve, myLastParam, P1, V1, V2);
183         }
184         P = myPoints[0] ;
185         VV = gp_Vec(P1, P);
186         NormD1 = VV.Magnitude();
187         if ( NormD1 < myDeflection) {
188           myParams[1]= myLastParam;
189           myPoints[1]= P1 ;
190         }
191         else {
192           myFirstParam = (myLastParam * (myParams[1] - Un1) + Un1 * myDu)
193               /(myFirstParam -Un1);
194           if (my3d)
195             D03d(myCurve, myFirstParam, P2);
196           else
197             D02d(myCurve, myFirstParam, P2);
198
199           if ((VV.CrossMagnitude(gp_Vec(P2, P)) / NormD1 < myDeflection) && 
200               (Un1 >= myLastParam - myDwmax) ) {
201             // point n is removed
202             myParams[1]= myLastParam;
203             myPoints[1] = P1 ;
204           }
205           else {
206             myParams[1]=myFirstParam;
207             myPoints[1] = P2 ;
208             myParams[2]=myLastParam;
209             myPoints[2] = P1 ;
210             myNbPoints = myNbPoints +1;  
211           }
212         }
213       }
214     }
215     else {
216       myNbPoints = myNbPoints +1 ;
217       if (myNbPoints >= 3) myNbPoints = 2;
218       myParams[myNbPoints]= myLastParam;
219       if (my3d) {
220           D03d(myCurve, myLastParam, myPoints[myNbPoints]);
221         }
222         else {
223           D02d(myCurve, myLastParam, myPoints[myNbPoints]);
224         }
225     }
226   }
227 }
228
229 //=======================================================================
230 //function : CPnts_UniformDeflection
231 //purpose  : 
232 //=======================================================================
233
234 CPnts_UniformDeflection::CPnts_UniformDeflection () 
235
236   myDone = Standard_False;
237
238
239 //=======================================================================
240 //function : CPnts_UniformDeflection
241 //purpose  : 
242 //=======================================================================
243
244 CPnts_UniformDeflection::CPnts_UniformDeflection 
245                                        (const Adaptor3d_Curve& C, 
246                                         const Standard_Real Deflection,
247                                         const Standard_Real Resolution,
248                                         const Standard_Boolean WithControl)
249 {
250   Initialize(C, Deflection, Resolution, WithControl);
251 }
252
253 //=======================================================================
254 //function : CPnts_UniformDeflection
255 //purpose  : 
256 //=======================================================================
257
258 CPnts_UniformDeflection::CPnts_UniformDeflection 
259                                        (const Adaptor2d_Curve2d& C, 
260                                         const Standard_Real Deflection,
261                                         const Standard_Real Resolution,
262                                         const Standard_Boolean WithControl)
263 {
264   Initialize(C, Deflection, Resolution, WithControl);
265 }
266
267 //=======================================================================
268 //function : Initialize
269 //purpose  : 
270 //=======================================================================
271
272 void CPnts_UniformDeflection::Initialize(const Adaptor3d_Curve& C, 
273                                          const Standard_Real Deflection,
274                                          const Standard_Real Resolution,
275                                          const Standard_Boolean WithControl)
276 {
277   Initialize(C,Deflection,C.FirstParameter(),C.LastParameter(),
278              Resolution,WithControl);
279 }
280
281 //=======================================================================
282 //function : Initialize
283 //purpose  : 
284 //=======================================================================
285
286 void CPnts_UniformDeflection::Initialize(const Adaptor2d_Curve2d& C, 
287                                          const Standard_Real Deflection,
288                                          const Standard_Real Resolution,
289                                          const Standard_Boolean WithControl)
290 {
291   Initialize(C,Deflection,C.FirstParameter(),C.LastParameter(),
292              Resolution,WithControl);
293 }
294
295 //=======================================================================
296 //function : CPnts_UniformDeflection
297 //purpose  : 
298 //=======================================================================
299
300 CPnts_UniformDeflection ::CPnts_UniformDeflection
301                                       (const Adaptor3d_Curve& C,
302                                        const Standard_Real Deflection, 
303                                        const Standard_Real U1,
304                                        const Standard_Real U2,
305                                        const Standard_Real Resolution,
306                                        const Standard_Boolean WithControl)
307 {
308   Initialize(C, Deflection, U1, U2, Resolution, WithControl);
309 }
310
311 //=======================================================================
312 //function : CPnts_UniformDeflection
313 //purpose  : 
314 //=======================================================================
315
316 CPnts_UniformDeflection ::CPnts_UniformDeflection
317                                       (const Adaptor2d_Curve2d& C,
318                                        const Standard_Real Deflection, 
319                                        const Standard_Real U1,
320                                        const Standard_Real U2,
321                                        const Standard_Real Resolution,
322                                        const Standard_Boolean WithControl)
323 {
324   Initialize(C, Deflection, U1, U2, Resolution, WithControl);
325 }
326
327 //=======================================================================
328 //function : Initialize
329 //purpose  : 
330 //=======================================================================
331
332 void CPnts_UniformDeflection::Initialize (const Adaptor3d_Curve& C,
333                                           const Standard_Real Deflection, 
334                                           const Standard_Real U1,
335                                           const Standard_Real U2,
336                                           const Standard_Real Resolution,
337                                           const Standard_Boolean WithControl)
338 {
339   if (U1 > U2) {
340     myFirstParam = U2;
341     myLastParam  = U1;
342   }
343   else {
344     myFirstParam = U1;
345     myLastParam  = U2;
346   }
347   my3d         = Standard_True;
348   myDwmax      = myLastParam-myFirstParam;
349   myDu         = myDwmax/2. ;
350   myDone       = Standard_True;
351   myCurve      = (Standard_Address) &C;
352   myFinish     = Standard_False;
353   myTolCur     = Resolution;
354   myDeflection = Deflection;
355   myControl    = WithControl;
356   Perform();
357 }
358
359 //=======================================================================
360 //function : Initialize
361 //purpose  : 
362 //=======================================================================
363
364 void CPnts_UniformDeflection::Initialize (const Adaptor2d_Curve2d& C,
365                                           const Standard_Real Deflection, 
366                                           const Standard_Real U1,
367                                           const Standard_Real U2,
368                                           const Standard_Real Resolution,
369                                           const Standard_Boolean WithControl)
370 {
371   if (U1 > U2) {
372     myFirstParam = U2;
373     myLastParam  = U1;
374   }
375   else {
376     myFirstParam = U1;
377     myLastParam  = U2;
378   }
379   my3d         = Standard_False;
380   myDwmax      = myLastParam-myFirstParam;
381   myDu         = myDwmax/2. ;
382   myDone       = Standard_True;
383   myCurve      = (Standard_Address) &C;
384   myFinish     = Standard_False;
385   myTolCur     = Resolution;
386   myDeflection = Deflection;
387   myControl    = WithControl;
388   Perform();
389 }
390
391 //=======================================================================
392 //function : More
393 //purpose  : 
394 //=======================================================================
395
396 Standard_Boolean CPnts_UniformDeflection::More()
397 {
398   if(!myDone) {
399     return Standard_False;
400   }
401   else if (myIPoint == myNbPoints) {
402     if (myFinish) {
403       return Standard_False;
404     }
405     else {
406       Perform();
407       return myDone;
408     }
409   }
410   else {
411     return myIPoint < myNbPoints;
412   }
413 }
414
415
416
417
418
419
420