0fd0df02b48e30d9fbfc2900e0abf399d763184e
[occt.git] / src / Contap / Contap_HContToolGen.gxx
1 // Created on: 1995-07-02
2 // Created by: Laurent BUCHARD
3 // Copyright (c) 1995-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 #include <Extrema_EPCOfExtPC2d.hxx>
18 #include <Extrema_POnCurv2d.hxx>
19
20 #include <GeomAbs_SurfaceType.hxx>
21 #include <Standard_OutOfRange.hxx>
22
23 #include <Geom_BezierSurface.hxx>
24 #include <Geom_BSplineSurface.hxx>
25 #include <Geom2d_BezierCurve.hxx>
26 #include <Geom2d_BSplineCurve.hxx>
27
28 #include <Geom_BezierSurface.hxx>
29 #include <Geom_BSplineSurface.hxx>
30 #include <Geom2d_BezierCurve.hxx>
31 #include <Geom2d_BSplineCurve.hxx>
32
33 static Standard_Real uinf,vinf,usup,vsup;
34
35 #include TheHSurface_hxx
36 #include TheHCurve2d_hxx
37 #include TheHVertex_hxx
38
39
40 Standard_Integer Contap_HContToolGen::NbSamplesV
41   (const TheHSurface& S,
42    const Standard_Real ,
43    const Standard_Real )
44 {
45   Standard_Integer nbs;
46   GeomAbs_SurfaceType typS = S->GetType();
47   switch(typS) { 
48   case GeomAbs_Plane:
49     {
50       nbs = 2;
51     }
52     break;
53   case GeomAbs_BezierSurface: 
54     {
55       nbs =  3 + S->NbVPoles();
56     }
57     break;
58   case GeomAbs_BSplineSurface: 
59     {
60       //-- Handle_Geom_BSplineSurface& HBS=S->BSpline();
61       nbs = S->NbVKnots();
62       nbs*= S->VDegree();
63       if(nbs < 2) nbs=2;
64       
65     }
66     break;
67   case GeomAbs_Cylinder:
68   case GeomAbs_Cone:
69   case GeomAbs_Sphere:
70   case GeomAbs_Torus:
71   case GeomAbs_SurfaceOfRevolution:
72   case GeomAbs_SurfaceOfExtrusion:
73     {
74       nbs = 15;
75     }
76     break;
77     
78   default: 
79     {
80       nbs = 10;
81     }
82     break;
83   }
84   return(nbs);
85 }
86
87 Standard_Integer Contap_HContToolGen::NbSamplesU
88   (const TheHSurface& S,
89    const Standard_Real ,
90    const Standard_Real )
91 {
92   Standard_Integer nbs;
93   GeomAbs_SurfaceType typS = S->GetType();
94   switch(typS) { 
95   case GeomAbs_Plane:
96     {
97       nbs = 2;
98     }
99     break;
100   case GeomAbs_BezierSurface: 
101     {
102       nbs =  3 + S->NbUPoles();
103     }
104     break;
105   case GeomAbs_BSplineSurface: 
106     {
107       //-- Handle_Geom_BSplineSurface& HBS=S->BSpline();
108       nbs = S->NbUKnots();
109       nbs*= S->UDegree();
110       if(nbs < 2) nbs=2;
111       
112     }
113     break;
114   case GeomAbs_Torus: 
115     {
116       nbs = 20;
117     }
118     break;
119   case GeomAbs_Cylinder:
120   case GeomAbs_Cone:
121   case GeomAbs_Sphere:
122   case GeomAbs_SurfaceOfRevolution:
123   case GeomAbs_SurfaceOfExtrusion:
124     {
125       nbs = 10;
126     }
127     break;
128     
129   default: 
130     {
131       nbs = 10;
132     }
133     break;
134   }
135   return(nbs);
136 }
137
138 Standard_Integer Contap_HContToolGen::NbSamplePoints
139   (const TheHSurface& S)
140 {
141   uinf = S->FirstUParameter();
142   usup = S->LastUParameter();
143   vinf = S->FirstVParameter();
144   vsup = S->LastVParameter();
145
146   if (usup < uinf) {
147     Standard_Real temp = uinf;
148     uinf = usup;
149     usup = temp;
150     }
151     if (vsup < vinf) {
152     Standard_Real temp = vinf;
153     vinf = vsup;
154     vsup = temp;
155   }
156   if (uinf == RealFirst() && usup == RealLast()) {
157     uinf = -1.e5;
158     usup =  1.e5;
159   }
160   else if (uinf == RealFirst()) {
161     uinf = usup - 2.e5;
162   }
163   else if (usup == RealLast()) {
164     usup = uinf + 2.e5;
165   }
166   
167   if (vinf == RealFirst() && vsup == RealLast()) {
168     vinf = -1.e5;
169     vsup =  1.e5;
170   }
171   else if (vinf == RealFirst()) {
172     vinf = vsup - 2.e5;
173   }
174   else if (vsup == RealLast()) {
175     vsup = vinf + 2.e5;
176   }
177   if(S->GetType() ==   GeomAbs_BSplineSurface) { 
178     Standard_Integer m = (NbSamplesU(S,uinf,usup)/3) * (NbSamplesV(S,vinf,vsup)/3);
179     if(m>5) return(m); 
180     else return(5);
181   }
182   else 
183     return 5;
184 }
185
186 void Contap_HContToolGen::SamplePoint (const TheHSurface& S,
187                                      const Standard_Integer Index,
188                                      Standard_Real& U,
189                                      Standard_Real& V )
190 {
191   if(S->GetType() ==   GeomAbs_BSplineSurface) {
192     Standard_Integer nbIntU = NbSamplesU(S,uinf,usup)/3;
193     Standard_Integer nbIntV = NbSamplesV(S,vinf,vsup)/3;
194     if(nbIntU * nbIntV >5) { 
195       Standard_Integer indU = (Index-1)/nbIntU;                  //----   0 --> nbIntV
196       Standard_Integer indV = (Index-1) - indU*nbIntU;           //----   0 --> nbIntU
197       
198       U = uinf + ((usup-uinf)/((Standard_Real)(nbIntU+1)))*(Standard_Real)(indU+1);
199       V = vinf + ((vsup-vinf)/((Standard_Real)(nbIntV+2)))*(Standard_Real)(indV+1);
200       
201       //-- cout<<"Index :"<<Index<<"  uinf:"<<uinf<<"  usup:"<<usup<<"  vinf:"<<vinf<<" vsup:"<<vsup<<"  ";
202       //-- cout<<"  ("<<indU<<"/"<<nbIntU<<" ->U:"<<U<<"  ";
203       //-- cout<<"  ("<<indV<<"/"<<nbIntV<<" ->V:"<<V<<endl;
204       return;
205     }
206   }
207   
208   switch (Index) {
209   case 1:
210     U = 0.75*uinf + 0.25*usup; //0.25;
211     V = 0.75*vinf + 0.25*vsup; //0.25;
212     break;
213   case 2:
214     U = 0.75*uinf + 0.25*usup; //0.25;
215     V = 0.25*vinf + 0.75*vsup; //0.75;
216     break;
217   case 3:
218     U = 0.25*uinf + 0.75*usup; //0.75;
219     V = 0.75*vinf + 0.25*vsup; //0.25;
220     break;
221   case 4:
222     U = 0.25*uinf + 0.75*usup; //0.75;
223     V = 0.25*vinf + 0.75*vsup; //0.75;
224     break;
225   default:
226     U = 0.5*(uinf+usup); //0.5;
227     V = 0.5*(vinf+vsup); //0.5;
228   }
229 }
230
231
232 Standard_Integer Contap_HContToolGen::NbSamplesOnArc
233   (const TheHCurve2d& A) { 
234
235   GeomAbs_CurveType CurveType  = A->GetType();
236
237   Standard_Real nbsOnC = 5;
238   switch(CurveType) { 
239   case GeomAbs_Line:
240     nbsOnC = 2;
241     break;
242   case GeomAbs_Circle:
243   case GeomAbs_Ellipse:
244   case GeomAbs_Hyperbola:
245   case GeomAbs_Parabola:
246     nbsOnC = 10;
247     break;
248   case GeomAbs_BezierCurve:
249     nbsOnC = A->NbPoles();
250     break;
251   case GeomAbs_BSplineCurve: { 
252     //-- Handle_Geom2d_BSplineCurve& BSC=A->BSpline();
253     nbsOnC = 2 + A->NbKnots() * A->Degree();
254     break;
255   }
256   default:
257     nbsOnC = 10;
258   } 
259   return (Standard_Integer)(nbsOnC);
260 }
261
262
263 void Contap_HContToolGen::Bounds(const TheHCurve2d& A,
264                                Standard_Real& Ufirst,
265                                Standard_Real& Ulast)
266 {
267   Ufirst = A->FirstParameter();
268   Ulast  = A->LastParameter();
269 }
270
271
272 Standard_Boolean Contap_HContToolGen::Project (const TheHCurve2d& C,
273                                                  const gp_Pnt2d& P,
274                                                  Standard_Real& Paramproj,
275                                                  gp_Pnt2d& Ptproj)
276
277 {
278
279   Standard_Real epsX = 1.e-8;
280   Standard_Integer Nbu = 20;
281   Standard_Real Tol = 1.e-5;
282   Standard_Real Dist2;
283
284   Extrema_EPCOfExtPC2d extrema(P,C->Curve2d(),Nbu,epsX,Tol);
285   if (!extrema.IsDone()) {
286     return Standard_False;
287   }
288   Standard_Integer Nbext = extrema.NbExt();
289   if (Nbext == 0) {
290     return Standard_False;
291   }
292   Standard_Integer indexmin = 1;
293   Dist2 = extrema.SquareDistance(1);
294   for (Standard_Integer i=2; i<=Nbext; i++) {
295     if (extrema.SquareDistance(i) < Dist2) {
296       indexmin = i;
297       Dist2 = extrema.SquareDistance(i);
298     }
299   }
300   Paramproj = extrema.Point(indexmin).Parameter();
301   Ptproj = extrema.Point(indexmin).Value();
302   return Standard_True;
303 }
304
305
306 Standard_Real Contap_HContToolGen::Tolerance (const TheHVertex& V,
307                                             const TheHCurve2d& C)
308 {
309 //  return BRepAdaptor2d_Curve2dTool::Resolution(C,BRep_Tool::Tolerance(V));
310   return V->Resolution(C);
311 }
312
313 Standard_Real Contap_HContToolGen::Parameter (const TheHVertex& V,
314                                             const TheHCurve2d& C)
315 {
316 //  return BRep_Tool::Parameter(V,C.Edge());
317   return V->Parameter(C);
318 }
319
320
321
322 Standard_Boolean Contap_HContToolGen::HasBeenSeen
323   (const TheHCurve2d&)
324 {
325   return Standard_False;
326 }
327
328 Standard_Integer Contap_HContToolGen::NbPoints(const TheHCurve2d&)
329 {
330   return 0;
331 }
332
333 void Contap_HContToolGen::Value(const TheHCurve2d&,
334                               const Standard_Integer,
335                               gp_Pnt&,
336                               Standard_Real&,
337                               Standard_Real&)
338 {
339   Standard_OutOfRange::Raise();
340 }
341
342 Standard_Boolean Contap_HContToolGen::IsVertex(const TheHCurve2d&,
343                                              const Standard_Integer)
344 {
345   return Standard_False;
346 }
347
348 void Contap_HContToolGen::Vertex(const TheHCurve2d&,
349                                const Standard_Integer,
350                                TheHVertex&)
351 {
352   Standard_OutOfRange::Raise();
353 }
354
355 Standard_Integer Contap_HContToolGen::NbSegments(const TheHCurve2d&)
356 {
357   return 0;
358 }
359
360 Standard_Boolean Contap_HContToolGen::HasFirstPoint
361   (const TheHCurve2d&,
362    const Standard_Integer,
363    Standard_Integer&)
364 {
365   Standard_OutOfRange::Raise();
366     return Standard_False;
367 }
368
369 Standard_Boolean Contap_HContToolGen::HasLastPoint
370   (const TheHCurve2d&,
371    const Standard_Integer,
372    Standard_Integer&)
373 {
374   Standard_OutOfRange::Raise();
375     return Standard_False;
376 }
377
378 Standard_Boolean Contap_HContToolGen::IsAllSolution
379   (const TheHCurve2d&)
380
381 {
382   return Standard_False;
383 }
384