0023024: Update headers of OCCT files
[occt.git] / src / ApproxInt / ApproxInt_PrmPrmSvSurfaces.gxx
1 // Created on: 1993-03-17
2 // Created by: Laurent BUCHARD
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22 #define TOLTANGENCY 0.0000000001
23
24
25 #include <TColStd_Array1OfReal.hxx>
26 #include <math_FunctionSetRoot.hxx>
27
28 #define Debug(expr)  cout<<" expr :"<<expr;
29 #define MySurf1 MyIntersectionOn2S.Function().AuxillarSurface1()
30 #define MySurf2 MyIntersectionOn2S.Function().AuxillarSurface2()
31
32
33 //--------------------------------------------------------------------------------
34 ApproxInt_PrmPrmSvSurfaces::ApproxInt_PrmPrmSvSurfaces( const ThePSurface& Surf1
35                                                        ,const ThePSurface& Surf2):
36        MyHasBeenComputed(Standard_False),
37        MyHasBeenComputedbis(Standard_False),
38        MyIntersectionOn2S(Surf1,Surf2,TOLTANGENCY)
39
40 }
41 //--------------------------------------------------------------------------------
42 Standard_Boolean ApproxInt_PrmPrmSvSurfaces::Compute( Standard_Real& u1
43                                                      ,Standard_Real& v1
44                                                      ,Standard_Real& u2
45                                                      ,Standard_Real& v2
46                                                      ,gp_Pnt& P
47                                                      ,gp_Vec& Tg
48                                                      ,gp_Vec2d& Tguv1
49                                                      ,gp_Vec2d& Tguv2) { 
50   
51   Standard_Real tu1=u1;
52   Standard_Real tu2=u2;
53   Standard_Real tv1=v1;
54   Standard_Real tv2=v2;
55   
56   if(MyHasBeenComputed) { 
57     if(  (MyParOnS1.X()==u1)&&(MyParOnS1.Y()==v1)
58        &&(MyParOnS2.X()==u2)&&(MyParOnS2.Y()==v2)) {
59       return(MyIsTangent);
60     }
61     else if(MyHasBeenComputedbis == Standard_False) { 
62       MyTgbis         = MyTg;
63       MyTguv1bis      = MyTguv1;
64       MyTguv2bis      = MyTguv2;
65       MyPntbis        = MyPnt;
66       MyParOnS1bis    = MyParOnS1;
67       MyParOnS2bis    = MyParOnS2;
68       MyIsTangentbis  = MyIsTangent;
69       MyHasBeenComputedbis = MyHasBeenComputed; 
70     }
71   }
72   if(MyHasBeenComputedbis) { 
73     if(  (MyParOnS1bis.X()==u1)&&(MyParOnS1bis.Y()==v1)
74        &&(MyParOnS2bis.X()==u2)&&(MyParOnS2bis.Y()==v2)) {
75
76       gp_Vec            TV(MyTg);
77       gp_Vec2d          TV1(MyTguv1);
78       gp_Vec2d          TV2(MyTguv2);
79       gp_Pnt            TP(MyPnt);
80       gp_Pnt2d          TP1(MyParOnS1);
81       gp_Pnt2d          TP2(MyParOnS2);
82       Standard_Boolean  TB=MyIsTangent;
83
84       MyTg        = MyTgbis;
85       MyTguv1     = MyTguv1bis;
86       MyTguv2     = MyTguv2bis;
87       MyPnt       = MyPntbis;
88       MyParOnS1   = MyParOnS1bis;
89       MyParOnS2   = MyParOnS2bis;
90       MyIsTangent = MyIsTangentbis;
91
92       MyTgbis         = TV;
93       MyTguv1bis      = TV1;
94       MyTguv2bis      = TV2;
95       MyPntbis        = TP;
96       MyParOnS1bis    = TP1;
97       MyParOnS2bis    = TP2;
98       MyIsTangentbis  = TB;
99
100       return(MyIsTangent);
101     }
102   }
103
104
105   MyIsTangent = Standard_True;
106
107   static TColStd_Array1OfReal Param(1,4);
108   Param(1) = u1; Param(2) = v1;
109   Param(3) = u2; Param(4) = v2;
110   math_FunctionSetRoot  Rsnld(MyIntersectionOn2S.Function());
111   MyIntersectionOn2S.Perform(Param,Rsnld);
112   if (!MyIntersectionOn2S.IsDone())  { 
113     MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
114     return(Standard_False);
115   }
116   if (MyIntersectionOn2S.IsEmpty()) {
117     MyIsTangent=Standard_False;
118     //cout<<"\n----- Parametree Parametree : IsEmpty ds Compute "<<endl;
119     //Debug(u1); Debug(u2); Debug(v1); Debug(v2);   cout<<endl;
120     MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
121     return(Standard_False);
122   }
123   MyHasBeenComputed = Standard_True;
124   MyPnt = P = MyIntersectionOn2S.Point().Value();
125   
126   MyIntersectionOn2S.Point().Parameters(u1,v1,u2,v2);
127   MyParOnS1.SetCoord(tu1,tv1);
128   MyParOnS2.SetCoord(tu2,tv2);
129   
130   if(MyIntersectionOn2S.IsTangent()) { 
131     MyIsTangent=Standard_False;
132     MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
133     return(Standard_False); 
134   }
135   MyTg    = Tg    = MyIntersectionOn2S.Direction();
136   MyTguv1 = Tguv1 = MyIntersectionOn2S.DirectionOnS1();
137   MyTguv2 = Tguv2 = MyIntersectionOn2S.DirectionOnS2();
138
139   //----------------------------------------------------------------------
140   //-- Si ( Tg )    TU et TV sont normes 
141   //-- 
142   //-- On a    Tg   =  DeltaU  *  TU    +   DeltaV  *  TV
143   //-- 
144   //-- soit :  Tg.TU  =  DeltaU  TU.TU  +   DeltaV  TU.TV
145   //--         Tg.TV  =  DeltaU  TV.TU  +   DeltaV  TV.TV 
146   //-- 
147   //-- Donc : 
148   //--
149   //--               Tg.TU TV.TV  - Tg.TV * TU.TV
150   //--   DeltaU = -------------------------------
151   //--               TU.TU TV.TV  - (TU.TV)**2
152   //-- 
153   //--               Tg.TV TU.TU  - Tg.TU * TU.TV
154   //--   DeltaV = -------------------------------
155   //--               TU.TU TV.TV  - (TU.TV)**2
156   //--
157   //--
158
159   Tg.Normalize();    MyTg = Tg; 
160
161   Standard_Real DeltaU,DeltaV;
162   gp_Vec TU,TV;
163   gp_Pnt Pbid;
164   Standard_Real TUTV,TgTU,TgTV,TUTU,TVTV,DIS;
165   //------------------------------------------------------------
166   //-- Calcul de Tguv1
167   //--
168   ThePSurfaceTool::D1(MySurf1,u1,v1,Pbid,TU,TV);
169   
170   TUTU = TU.Dot(TU);
171   TVTV = TV.Dot(TV);
172   TUTV = TU.Dot(TV);
173   TgTU = Tg.Dot(TU);
174   TgTV = Tg.Dot(TV);
175   DIS  = TUTU * TVTV - TUTV * TUTV;
176   
177   DeltaU = (TgTU * TVTV - TgTV * TUTV ) / DIS ; 
178   DeltaV = (TgTV * TUTU - TgTU * TUTV ) / DIS ;
179
180   Tguv1.SetCoord(DeltaU,DeltaV);  MyTguv1 = Tguv1;
181
182   //------------------------------------------------------------
183   //-- Calcul de Tguv2
184   //--  
185   ThePSurfaceTool::D1(MySurf2,u2,v2,Pbid,TU,TV);
186
187   TUTU = TU.Dot(TU);
188   TVTV = TV.Dot(TV);
189   TUTV = TU.Dot(TV);
190   TgTU = Tg.Dot(TU);
191   TgTV = Tg.Dot(TV);
192   DIS  = TUTU * TVTV - TUTV * TUTV;
193
194   DeltaU = (TgTU * TVTV - TgTV * TUTV ) / DIS ; 
195   DeltaV = (TgTV * TUTU - TgTU * TUTV ) / DIS ;
196   
197   Tguv2.SetCoord(DeltaU,DeltaV);  MyTguv2 = Tguv2;
198
199   return(Standard_True);
200 }
201 //--------------------------------------------------------------------------------
202 void ApproxInt_PrmPrmSvSurfaces::Pnt(const Standard_Real u1,
203                                      const Standard_Real v1,
204                                      const Standard_Real u2,
205                                      const Standard_Real v2,
206                                      gp_Pnt& P) { 
207   gp_Pnt aP;
208   gp_Vec aT;
209   gp_Vec2d aTS1,aTS2;
210   Standard_Real tu1=u1;
211   Standard_Real tu2=u2;
212   Standard_Real tv1=v1;
213   Standard_Real tv2=v2;
214 #ifdef DEB
215   Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
216 #else
217   this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
218 #endif
219   P=MyPnt;
220 }
221 //--------------------------------------------------------------------------------
222 Standard_Boolean ApproxInt_PrmPrmSvSurfaces::Tangency(const Standard_Real u1,
223                                                       const Standard_Real v1,
224                                                       const Standard_Real u2,
225                                                       const Standard_Real v2,
226                                                       gp_Vec& T) { 
227   gp_Pnt aP;
228   gp_Vec aT;
229   gp_Vec2d aTS1,aTS2;
230   Standard_Real tu1=u1;
231   Standard_Real tu2=u2;
232   Standard_Real tv1=v1;
233   Standard_Real tv2=v2;
234   Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
235   T=MyTg;
236   return(t);
237 }
238 //--------------------------------------------------------------------------------
239 Standard_Boolean ApproxInt_PrmPrmSvSurfaces::TangencyOnSurf1(const Standard_Real u1,
240                                                              const Standard_Real v1,
241                                                              const Standard_Real u2,
242                                                              const Standard_Real v2,
243                                                              gp_Vec2d& T) { 
244   gp_Pnt aP;
245   gp_Vec aT;
246   gp_Vec2d aTS1,aTS2;
247   Standard_Real tu1=u1;
248   Standard_Real tu2=u2;
249   Standard_Real tv1=v1;
250   Standard_Real tv2=v2;
251   Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
252   T=MyTguv1;
253   return(t);
254 }
255 //--------------------------------------------------------------------------------
256 Standard_Boolean ApproxInt_PrmPrmSvSurfaces::TangencyOnSurf2(const Standard_Real u1,
257                                                              const Standard_Real v1,
258                                                              const Standard_Real u2,
259                                                              const Standard_Real v2,
260                                                              gp_Vec2d& T) { 
261   gp_Pnt aP;
262   gp_Vec aT;
263   gp_Vec2d aTS1,aTS2;
264   Standard_Real tu1=u1;
265   Standard_Real tu2=u2;
266   Standard_Real tv1=v1;
267   Standard_Real tv2=v2;
268   Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
269   T=MyTguv2;
270   return(t);
271 }
272 //--------------------------------------------------------------------------------
273
274
275
276
277 #if 0 
278   //------------------------------------------------------------
279   //-- Calcul de Tguv1
280   //--
281   ThePSurfaceTool::D1(MySurf1,u1,v1,P,TU,TV);
282   
283   TUTV = TU.Dot(TV);
284   TgTU = Tg.Dot(TU);
285   TgTV = Tg.Dot(TV);
286   UmTUTV2 = 1.0 - TUTV * TUTV;
287   
288   DeltaU = (TgTU - TgTV * TUTV ) / UmTUTV2 ; 
289   DeltaV = (TgTV - TgTU * TUTV ) / UmTUTV2 ;
290
291   Delta = 1.0 / Sqrt(DeltaU * DeltaU + DeltaV * DeltaV);
292   
293   Tguv1.Multiplied(Delta);  MyTguv1 = Tguv1;
294
295   //------------------------------------------------------------
296   //-- Calcul de Tguv2
297   //--  
298   ThePSurfaceTool::D1(MySurf2,u2,v2,P,TU,TV);
299
300   TUTV = TU.Dot(TV);
301   TgTU = Tg.Dot(TU);
302   TgTV = Tg.Dot(TV);
303   UmTUTV2 = 1.0 - TUTV * TUTV;
304   
305   DeltaU = (TgTU - TgTV * TUTV ) / UmTUTV2 ; 
306   DeltaV = (TgTV - TgTU * TUTV ) / UmTUTV2 ;
307   
308   Delta = 1.0 / Sqrt(DeltaU * DeltaU + DeltaV * DeltaV);
309   
310   Tguv2.Multiplied(Delta);  MyTguv2 = Tguv2;
311
312   return(Standard_True);
313 }
314 #endif
315
316
317
318