src/Contap/Contap_SurfFunction.cxx

   1 // Created on: 1993-06-03
   2 // Created by: Jacques GOUSSARD
   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 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 // jag 940616 Tolpetit = 1.e-16
  18
  19 #include <Adaptor3d_HSurface.hxx>
  20 #include <Adaptor3d_HSurfaceTool.hxx>
  21 #include <Contap_HContTool.hxx>
  22 #include <Contap_SurfFunction.hxx>
  23 #include <Contap_SurfProps.hxx>
  24 #include <gp_Dir.hxx>
  25 #include <gp_Dir2d.hxx>
  26 #include <gp_Pnt.hxx>
  27 #include <gp_Vec.hxx>
  28 #include <math_Matrix.hxx>
  29 #include <StdFail_UndefinedDerivative.hxx>
  30
  31 Contap_SurfFunction::Contap_SurfFunction ():
  32   myMean(1.),
  33   myType(Contap_ContourStd),
  34   myDir(0.,0.,1.),
  35   myCosAng(0.), // PI/2 - Angle de depouille
  36   tol(1.e-6),
  37   computed(Standard_False),
  38   derived(Standard_False)
  39 {}
  40
  41 void Contap_SurfFunction::Set(const Handle(Adaptor3d_HSurface)& S)
  42 {
  43   mySurf = S;
  44   Standard_Integer i;
  45   Standard_Integer nbs = Contap_HContTool::NbSamplePoints(S);
  46   Standard_Real U,V;
  47   gp_Vec norm;
  48   if (nbs > 0) {
  49     myMean = 0.;
  50     for (i = 1; i <= nbs; i++) {
  51       Contap_HContTool::SamplePoint(S,i,U,V);
  52       //      Adaptor3d_HSurfaceTool::D1(S,U,V,solpt,d1u,d1v);
  53       //      myMean = myMean + d1u.Crossed(d1v).Magnitude();
  54       Contap_SurfProps::Normale(S,U,V,solpt,norm);
  55       myMean = myMean + norm.Magnitude();
  56     }
  57     myMean = myMean / ((Standard_Real)nbs);
  58   }
  59   computed = Standard_False;
  60   derived = Standard_False;
  61 }
  62
  63
  64 Standard_Integer Contap_SurfFunction::NbVariables () const
  65 {
  66   return 2;
  67 }
  68
  69 Standard_Integer Contap_SurfFunction::NbEquations () const
  70 {
  71   return 1;
  72 }
  73
  74
  75 Standard_Boolean Contap_SurfFunction::Value(const math_Vector& X,
  76                                             math_Vector& F)
  77 {
  78   Usol = X(1); Vsol = X(2);
  79   //  Adaptor3d_HSurfaceTool::D1(mySurf,Usol,Vsol,solpt,d1u,d1v);
  80   //  gp_Vec norm(d1u.Crossed(d1v));
  81   gp_Vec norm;
  82   Contap_SurfProps::Normale(mySurf,Usol,Vsol,solpt,norm);
  83   switch (myType) {
  84   case Contap_ContourStd:
  85     {
  86       F(1) = valf = (norm.Dot(myDir))/myMean;
  87     }
  88     break;
  89   case Contap_ContourPrs:
  90     {
  91       F(1) = valf = (norm.Dot(gp_Vec(myEye,solpt)))/myMean;
  92     }
  93     break;
  94   case Contap_DraftStd:
  95     {
  96       F(1) = valf = (norm.Dot(myDir)-myCosAng*norm.Magnitude())/myMean;
  97     }
  98     break;
  99   default:
 100     {
 101     }
 102   }
 103   computed = Standard_False;
 104   derived = Standard_False;
 105   return Standard_True;
 106 }
 107
 108
 109 Standard_Boolean Contap_SurfFunction::Derivatives(const math_Vector& X,
 110                                                   math_Matrix& Grad)
 111 {
 112   //  gp_Vec d2u,d2v,d2uv;
 113   Usol = X(1); Vsol = X(2);
 114   //  Adaptor3d_HSurfaceTool::D2(mySurf,Usol,Vsol,solpt,d1u,d1v,d2u,d2v,d2uv);
 115
 116   gp_Vec norm,dnu,dnv;
 117   Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
 118
 119   switch (myType) {
 120   case Contap_ContourStd:
 121     {
 122       //      Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
 123       //      Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
 124       Grad(1,1) = (dnu.Dot(myDir))/myMean;
 125       Grad(1,2) = (dnv.Dot(myDir))/myMean;
 126     }
 127     break;
 128   case Contap_ContourPrs:
 129     {
 130       gp_Vec Ep(myEye,solpt);
 131       Grad(1,1) = (dnu.Dot(Ep))/myMean;
 132       Grad(1,2) = (dnv.Dot(Ep))/myMean;
 133     }
 134     break;
 135   case Contap_DraftStd:
 136     {
 137       //      gp_Vec norm(d1u.Crossed(d1v).Normalized());
 138       //      gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
 139       //      Grad(1,1) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
 140       //      dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
 141       //      Grad(1,2) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
 142       norm.Normalize();
 143       Grad(1,1) = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
 144       Grad(1,2) = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
 145     }
 146     break;
 147   case Contap_DraftPrs:
 148   default:
 149     {
 150     }
 151   }
 152   Fpu = Grad(1,1); Fpv = Grad(1,2);
 153   computed = Standard_False;
 154   derived = Standard_True;
 155   return Standard_True;
 156 }
 157
 158
 159 Standard_Boolean Contap_SurfFunction::Values (const math_Vector& X,
 160                                               math_Vector& F,
 161                                               math_Matrix& Grad)
 162 {
 163   //  gp_Vec d2u,d2v,d2uv;
 164
 165   Usol = X(1); Vsol = X(2);
 166   //  Adaptor3d_HSurfaceTool::D2(mySurf,Usol,Vsol,solpt,d1u,d1v,d2u,d2v,d2uv);
 167   //  gp_Vec norm(d1u.Crossed(d1v));
 168   gp_Vec norm,dnu,dnv;
 169   Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
 170
 171   switch (myType) {
 172
 173   case Contap_ContourStd:
 174     {
 175       F(1)      = (norm.Dot(myDir))/myMean;
 176       //      Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
 177       //      Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
 178       Grad(1,1) = (dnu.Dot(myDir))/myMean;
 179       Grad(1,2) = (dnv.Dot(myDir))/myMean;
 180     }
 181     break;
 182   case Contap_ContourPrs:
 183     {
 184       gp_Vec Ep(myEye,solpt);
 185       F(1)      = (norm.Dot(Ep))/myMean;
 186       //      Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean;
 187       //      Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean;
 188       Grad(1,1) = (dnu.Dot(Ep))/myMean;
 189       Grad(1,2) = (dnv.Dot(Ep))/myMean;
 190     }
 191     break;
 192   case Contap_DraftStd:
 193     {
 194       F(1) = (norm.Dot(myDir)-myCosAng*norm.Magnitude())/myMean;
 195       norm.Normalize();
 196       /*
 197       gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
 198       Grad(1,1) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
 199       dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
 200       Grad(1,2) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
 201       */
 202       Grad(1,1) = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
 203       Grad(1,2) = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
 204     }
 205     break;
 206   case Contap_DraftPrs:
 207   default:
 208     {
 209     }
 210   }
 211   valf = F(1);
 212   Fpu = Grad(1,1); Fpv = Grad(1,2);
 213   computed = Standard_False;
 214   derived = Standard_True;
 215   return Standard_True;
 216 }
 217
 218
 219 Standard_Boolean Contap_SurfFunction::IsTangent ()
 220 {
 221   if (!computed) {
 222     computed = Standard_True;
 223     if(!derived) {
 224       //      gp_Vec d2u,d2v,d2uv;
 225       //      Adaptor3d_HSurfaceTool::D2(mySurf, Usol, Vsol, solpt, d1u, d1v, d2u, d2v, d2uv);
 226       gp_Vec norm,dnu,dnv;
 227       Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
 228
 229       switch (myType) {
 230       case Contap_ContourStd:
 231         {
 232           //      Fpu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
 233           //      Fpv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
 234           Fpu = (dnu.Dot(myDir))/myMean;
 235           Fpv = (dnv.Dot(myDir))/myMean;
 236         }
 237         break;
 238       case Contap_ContourPrs:
 239         {
 240           gp_Vec Ep(myEye,solpt);
 241           //      Fpu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean;
 242           //      Fpv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean;
 243           Fpu = (dnu.Dot(Ep))/myMean;
 244           Fpv = (dnv.Dot(Ep))/myMean;
 245         }
 246         break;
 247       case Contap_DraftStd:
 248         {
 249           /*
 250           gp_Vec norm(d1u.Crossed(d1v).Normalized());
 251           gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
 252           Fpu = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
 253           dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
 254           Fpv = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
 255           */
 256           norm.Normalize();
 257           Fpu = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
 258           Fpv = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
 259         }
 260         break;
 261       case Contap_DraftPrs:
 262       default:
 263         {
 264         }
 265       }
 266       derived = Standard_True;
 267     }
 268     tangent = Standard_False;
 269     Standard_Real D = Sqrt (Fpu * Fpu + Fpv * Fpv);
 270
 271     if (D <= gp::Resolution()) {
 272       tangent = Standard_True;
 273     }
 274     else {
 275       d2d = gp_Dir2d(-Fpv,Fpu);
 276       gp_Vec d1u,d1v;
 277       Adaptor3d_HSurfaceTool::D1(mySurf, Usol, Vsol, solpt, d1u, d1v); // ajout jag 02.95
 278
 279       gp_XYZ d3dxyz(-Fpv*d1u.XYZ());
 280       d3dxyz.Add(Fpu*d1v.XYZ());
 281       d3d.SetXYZ(d3dxyz);
 282
 283       //jag 940616    if (d3d.Magnitude() <= Tolpetit) {
 284       if (d3d.Magnitude() <= tol) {
 285         tangent = Standard_True;
 286       }
 287     }
 288   }
 289   return tangent;
 290 }