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-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
   9 // under the terms of the GNU Lesser General Public 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 #define TOLTANGENCY 0.0000000001
  18
  19
  20 #include <TColStd_Array1OfReal.hxx>
  21 #include <math_FunctionSetRoot.hxx>
  22 #include <Precision.hxx>
  23
  24 #define Debug(expr)  cout<<" expr :"<<expr;
  25 #define MySurf1 MyIntersectionOn2S.Function().AuxillarSurface1()
  26 #define MySurf2 MyIntersectionOn2S.Function().AuxillarSurface2()
  27
  28
  29 //--------------------------------------------------------------------------------
  30 ApproxInt_PrmPrmSvSurfaces::ApproxInt_PrmPrmSvSurfaces( const ThePSurface& Surf1
  31                                                        ,const ThePSurface& Surf2):
  32        MyHasBeenComputed(Standard_False),
  33        MyHasBeenComputedbis(Standard_False),
  34        MyIntersectionOn2S(Surf1,Surf2,TOLTANGENCY)
  35 {
  36 }
  37 //--------------------------------------------------------------------------------
  38 Standard_Boolean ApproxInt_PrmPrmSvSurfaces::Compute( Standard_Real& u1
  39                                                      ,Standard_Real& v1
  40                                                      ,Standard_Real& u2
  41                                                      ,Standard_Real& v2
  42                                                      ,gp_Pnt& P
  43                                                      ,gp_Vec& Tg
  44                                                      ,gp_Vec2d& Tguv1
  45                                                      ,gp_Vec2d& Tguv2) {
  46
  47   Standard_Real tu1=u1;
  48   Standard_Real tu2=u2;
  49   Standard_Real tv1=v1;
  50   Standard_Real tv2=v2;
  51
  52   if(MyHasBeenComputed) {
  53     if(  (MyParOnS1.X()==u1)&&(MyParOnS1.Y()==v1)
  54        &&(MyParOnS2.X()==u2)&&(MyParOnS2.Y()==v2)) {
  55       return(MyIsTangent);
  56     }
  57     else if(MyHasBeenComputedbis == Standard_False) {
  58       MyTgbis         = MyTg;
  59       MyTguv1bis      = MyTguv1;
  60       MyTguv2bis      = MyTguv2;
  61       MyPntbis        = MyPnt;
  62       MyParOnS1bis    = MyParOnS1;
  63       MyParOnS2bis    = MyParOnS2;
  64       MyIsTangentbis  = MyIsTangent;
  65       MyHasBeenComputedbis = MyHasBeenComputed;
  66     }
  67   }
  68   if(MyHasBeenComputedbis) {
  69     if(  (MyParOnS1bis.X()==u1)&&(MyParOnS1bis.Y()==v1)
  70        &&(MyParOnS2bis.X()==u2)&&(MyParOnS2bis.Y()==v2)) {
  71
  72       gp_Vec            TV(MyTg);
  73       gp_Vec2d          TV1(MyTguv1);
  74       gp_Vec2d          TV2(MyTguv2);
  75       gp_Pnt            TP(MyPnt);
  76       gp_Pnt2d          TP1(MyParOnS1);
  77       gp_Pnt2d          TP2(MyParOnS2);
  78       Standard_Boolean  TB=MyIsTangent;
  79
  80       MyTg        = MyTgbis;
  81       MyTguv1     = MyTguv1bis;
  82       MyTguv2     = MyTguv2bis;
  83       MyPnt       = MyPntbis;
  84       MyParOnS1   = MyParOnS1bis;
  85       MyParOnS2   = MyParOnS2bis;
  86       MyIsTangent = MyIsTangentbis;
  87
  88       MyTgbis         = TV;
  89       MyTguv1bis      = TV1;
  90       MyTguv2bis      = TV2;
  91       MyPntbis        = TP;
  92       MyParOnS1bis    = TP1;
  93       MyParOnS2bis    = TP2;
  94       MyIsTangentbis  = TB;
  95
  96       return(MyIsTangent);
  97     }
  98   }
  99
 100
 101   MyIsTangent = Standard_True;
 102
 103   Standard_Real aParam[4];//stack vs heap allocation
 104   TColStd_Array1OfReal Param (aParam[0],1,4);
 105   Param(1) = u1; Param(2) = v1;
 106   Param(3) = u2; Param(4) = v2;
 107   math_FunctionSetRoot  Rsnld(MyIntersectionOn2S.Function());
 108   MyIntersectionOn2S.Perform(Param,Rsnld);
 109   if (!MyIntersectionOn2S.IsDone())  {
 110     MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
 111     return(Standard_False);
 112   }
 113   if (MyIntersectionOn2S.IsEmpty()) {
 114     MyIsTangent=Standard_False;
 115     //cout<<"\n----- Parametree Parametree : IsEmpty ds Compute "<<endl;
 116     //Debug(u1); Debug(u2); Debug(v1); Debug(v2);   cout<<endl;
 117     MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
 118     return(Standard_False);
 119   }
 120   MyHasBeenComputed = Standard_True;
 121   MyPnt = P = MyIntersectionOn2S.Point().Value();
 122
 123   MyIntersectionOn2S.Point().Parameters(u1,v1,u2,v2);
 124   MyParOnS1.SetCoord(tu1,tv1);
 125   MyParOnS2.SetCoord(tu2,tv2);
 126
 127   if(MyIntersectionOn2S.IsTangent()) {
 128     MyIsTangent=Standard_False;
 129     MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
 130     return(Standard_False);
 131   }
 132   MyTg    = Tg    = MyIntersectionOn2S.Direction();
 133   MyTguv1 = Tguv1 = MyIntersectionOn2S.DirectionOnS1();
 134   MyTguv2 = Tguv2 = MyIntersectionOn2S.DirectionOnS2();
 135
 136   //----------------------------------------------------------------------
 137   //-- Si ( Tg )    TU et TV sont normes
 138   //--
 139   //-- On a    Tg   =  DeltaU  *  TU    +   DeltaV  *  TV
 140   //--
 141   //-- soit :  Tg.TU  =  DeltaU  TU.TU  +   DeltaV  TU.TV
 142   //--         Tg.TV  =  DeltaU  TV.TU  +   DeltaV  TV.TV
 143   //--
 144   //-- Donc :
 145   //--
 146   //--               Tg.TU TV.TV  - Tg.TV * TU.TV
 147   //--   DeltaU = -------------------------------
 148   //--               TU.TU TV.TV  - (TU.TV)**2
 149   //--
 150   //--               Tg.TV TU.TU  - Tg.TU * TU.TV
 151   //--   DeltaV = -------------------------------
 152   //--               TU.TU TV.TV  - (TU.TV)**2
 153   //--
 154   //--
 155
 156   Tg.Normalize();    MyTg = Tg;
 157
 158   Standard_Real DeltaU,DeltaV;
 159   gp_Vec TU,TV;
 160   gp_Pnt Pbid;
 161   Standard_Real TUTV,TgTU,TgTV,TUTU,TVTV,DIS;
 162   //------------------------------------------------------------
 163   //-- Calcul de Tguv1
 164   //--
 165   ThePSurfaceTool::D1(MySurf1,u1,v1,Pbid,TU,TV);
 166
 167   TUTU = TU.Dot(TU);
 168   TVTV = TV.Dot(TV);
 169   TUTV = TU.Dot(TV);
 170   TgTU = Tg.Dot(TU);
 171   TgTV = Tg.Dot(TV);
 172   DIS  = TUTU * TVTV - TUTV * TUTV;
 173   if(fabs(DIS)<Precision::Angular()) {
 174     MyIsTangent=Standard_False;
 175     MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
 176     return(Standard_False);
 177   }
 178
 179   DeltaU = (TgTU * TVTV - TgTV * TUTV ) / DIS ;
 180   DeltaV = (TgTV * TUTU - TgTU * TUTV ) / DIS ;
 181
 182   Tguv1.SetCoord(DeltaU,DeltaV);  MyTguv1 = Tguv1;
 183
 184   //------------------------------------------------------------
 185   //-- Calcul de Tguv2
 186   //--
 187   ThePSurfaceTool::D1(MySurf2,u2,v2,Pbid,TU,TV);
 188
 189   TUTU = TU.Dot(TU);
 190   TVTV = TV.Dot(TV);
 191   TUTV = TU.Dot(TV);
 192   TgTU = Tg.Dot(TU);
 193   TgTV = Tg.Dot(TV);
 194   DIS  = TUTU * TVTV - TUTV * TUTV;
 195   if(fabs(DIS)<Precision::Angular()) {
 196     MyIsTangent=Standard_False;
 197     MyHasBeenComputed = MyHasBeenComputedbis = Standard_False;
 198     return(Standard_False);
 199   }
 200
 201   DeltaU = (TgTU * TVTV - TgTV * TUTV ) / DIS ;
 202   DeltaV = (TgTV * TUTU - TgTU * TUTV ) / DIS ;
 203
 204   Tguv2.SetCoord(DeltaU,DeltaV);  MyTguv2 = Tguv2;
 205
 206   return(Standard_True);
 207 }
 208 //--------------------------------------------------------------------------------
 209 void ApproxInt_PrmPrmSvSurfaces::Pnt(const Standard_Real u1,
 210                                      const Standard_Real v1,
 211                                      const Standard_Real u2,
 212                                      const Standard_Real v2,
 213                                      gp_Pnt& P) {
 214   gp_Pnt aP;
 215   gp_Vec aT;
 216   gp_Vec2d aTS1,aTS2;
 217   Standard_Real tu1=u1;
 218   Standard_Real tu2=u2;
 219   Standard_Real tv1=v1;
 220   Standard_Real tv2=v2;
 221   this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
 222   P=MyPnt;
 223 }
 224 //--------------------------------------------------------------------------------
 225 Standard_Boolean ApproxInt_PrmPrmSvSurfaces::Tangency(const Standard_Real u1,
 226                                                       const Standard_Real v1,
 227                                                       const Standard_Real u2,
 228                                                       const Standard_Real v2,
 229                                                       gp_Vec& T) {
 230   gp_Pnt aP;
 231   gp_Vec aT;
 232   gp_Vec2d aTS1,aTS2;
 233   Standard_Real tu1=u1;
 234   Standard_Real tu2=u2;
 235   Standard_Real tv1=v1;
 236   Standard_Real tv2=v2;
 237   Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
 238   T=MyTg;
 239   return(t);
 240 }
 241 //--------------------------------------------------------------------------------
 242 Standard_Boolean ApproxInt_PrmPrmSvSurfaces::TangencyOnSurf1(const Standard_Real u1,
 243                                                              const Standard_Real v1,
 244                                                              const Standard_Real u2,
 245                                                              const Standard_Real v2,
 246                                                              gp_Vec2d& T) {
 247   gp_Pnt aP;
 248   gp_Vec aT;
 249   gp_Vec2d aTS1,aTS2;
 250   Standard_Real tu1=u1;
 251   Standard_Real tu2=u2;
 252   Standard_Real tv1=v1;
 253   Standard_Real tv2=v2;
 254   Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
 255   T=MyTguv1;
 256   return(t);
 257 }
 258 //--------------------------------------------------------------------------------
 259 Standard_Boolean ApproxInt_PrmPrmSvSurfaces::TangencyOnSurf2(const Standard_Real u1,
 260                                                              const Standard_Real v1,
 261                                                              const Standard_Real u2,
 262                                                              const Standard_Real v2,
 263                                                              gp_Vec2d& T) {
 264   gp_Pnt aP;
 265   gp_Vec aT;
 266   gp_Vec2d aTS1,aTS2;
 267   Standard_Real tu1=u1;
 268   Standard_Real tu2=u2;
 269   Standard_Real tv1=v1;
 270   Standard_Real tv2=v2;
 271   Standard_Boolean t=this->Compute(tu1,tv1,tu2,tv2,aP,aT,aTS1,aTS2);
 272   T=MyTguv2;
 273   return(t);
 274 }
 275 //--------------------------------------------------------------------------------
 276
 277
 278
 279
 280 #if 0
 281   //------------------------------------------------------------
 282   //-- Calcul de Tguv1
 283   //--
 284   ThePSurfaceTool::D1(MySurf1,u1,v1,P,TU,TV);
 285
 286   TUTV = TU.Dot(TV);
 287   TgTU = Tg.Dot(TU);
 288   TgTV = Tg.Dot(TV);
 289   UmTUTV2 = 1.0 - TUTV * TUTV;
 290
 291   DeltaU = (TgTU - TgTV * TUTV ) / UmTUTV2 ;
 292   DeltaV = (TgTV - TgTU * TUTV ) / UmTUTV2 ;
 293
 294   Delta = 1.0 / Sqrt(DeltaU * DeltaU + DeltaV * DeltaV);
 295
 296   Tguv1.Multiplied(Delta);  MyTguv1 = Tguv1;
 297
 298   //------------------------------------------------------------
 299   //-- Calcul de Tguv2
 300   //--
 301   ThePSurfaceTool::D1(MySurf2,u2,v2,P,TU,TV);
 302
 303   TUTV = TU.Dot(TV);
 304   TgTU = Tg.Dot(TU);
 305   TgTV = Tg.Dot(TV);
 306   UmTUTV2 = 1.0 - TUTV * TUTV;
 307
 308   DeltaU = (TgTU - TgTV * TUTV ) / UmTUTV2 ;
 309   DeltaV = (TgTV - TgTU * TUTV ) / UmTUTV2 ;
 310
 311   Delta = 1.0 / Sqrt(DeltaU * DeltaU + DeltaV * DeltaV);
 312
 313   Tguv2.Multiplied(Delta);  MyTguv2 = Tguv2;
 314
 315   return(Standard_True);
 316 }
 317 #endif
 318
 319
 320
 321