src/IntCurve/IntCurve_IConicTool.cxx

   1 #include <IntCurve_IConicTool.ixx>
   2 #include <ElCLib.hxx>
   3 #include <gp.hxx>
   4
   5
   6 #define Object_To_Abs  Abs_To_Object.Inverted()
   7 //======================================================================
   8 #define Elips_a prm1
   9 #define Elips_b prm2
  10 #define Elips_c prm3
  11
  12 #define Elips_aa (Elips_a*Elips_a)
  13 #define Elips_bb (Elips_b*Elips_b)
  14 #define Elips_x0 (Axis.Location().X())
  15 #define Elips_y0 (Axis.Location().Y())
  16 //======================================================================
  17 #define Hypr_a prm1
  18 #define Hypr_b prm2
  19 #define Hypr_aa (Hypr_a * Hypr_a)
  20 #define Hypr_bb (Hypr_b * Hypr_b)
  21 //======================================================================
  22 #define Line_a prm1
  23 #define Line_b prm2
  24 #define Line_c prm3
  25 //======================================================================
  26 #define Circle_r  prm1
  27 #define Circle_x0 prm2
  28 #define Circle_y0 prm3
  29 //======================================================================
  30 #define Parab_f   prm1
  31 #define Parab_2p  prm2
  32
  33 //======================================================================
  34 IntCurve_IConicTool::IntCurve_IConicTool(void) {
  35 //###### PLACER LE TYPE NON DEFINI ######
  36 }
  37
  38
  39 IntCurve_IConicTool::IntCurve_IConicTool(const IntCurve_IConicTool& ITool) {
  40   prm1=ITool.prm1;
  41   prm2=ITool.prm2;
  42   prm3=ITool.prm3;
  43   Axis=ITool.Axis;
  44   Abs_To_Object=ITool.Abs_To_Object;
  45   type=ITool.type;
  46 }
  47 //======================================================================
  48 //======================================================================
  49 IntCurve_IConicTool::IntCurve_IConicTool(const gp_Lin2d& Line) {
  50   Line.Coefficients(Line_a,Line_b,Line_c);
  51   Axis = gp_Ax22d(Line.Position(),Standard_True);
  52   type = GeomAbs_Line;
  53 }
  54 //======================================================================
  55 IntCurve_IConicTool::IntCurve_IConicTool(const gp_Elips2d& Elips) {
  56   Elips_a = Elips.MajorRadius();
  57   Elips_b = Elips.MinorRadius();
  58   Elips_c = sqrt(Elips_a*Elips_a-Elips_b*Elips_b);
  59   Axis = Elips.Axis();
  60   Abs_To_Object.SetTransformation(gp::OX2d(),Axis.XAxis());
  61   type = GeomAbs_Ellipse;
  62 }
  63 //======================================================================
  64 IntCurve_IConicTool::IntCurve_IConicTool(const gp_Circ2d& C) {
  65   Circle_r=C.Radius();
  66   Axis=C.Axis();
  67   Circle_x0=Axis.Location().X();
  68   Circle_y0=Axis.Location().Y();
  69   Abs_To_Object.SetTransformation(gp::OX2d(),Axis.XAxis());
  70   type = GeomAbs_Circle;
  71 }
  72 //======================================================================
  73 IntCurve_IConicTool::IntCurve_IConicTool(const gp_Parab2d& P) {
  74   Parab_f=P.Focal();
  75   Parab_2p=4.0*Parab_f;
  76   Axis=P.Axis();
  77   Abs_To_Object.SetTransformation(gp::OX2d(),Axis.XAxis());
  78   type = GeomAbs_Parabola;
  79 }
  80 //======================================================================
  81 IntCurve_IConicTool::IntCurve_IConicTool(const gp_Hypr2d& H) {
  82   Hypr_a = H.MajorRadius();
  83   Hypr_b = H.MinorRadius();
  84   Axis = H.Axis();
  85   Abs_To_Object.SetTransformation(gp::OX2d(),Axis.XAxis());
  86   type = GeomAbs_Hyperbola;
  87 }
  88 //----------------------------------------------------------------------
  89 gp_Pnt2d IntCurve_IConicTool::Value(const Standard_Real X) const {
  90   switch(type) {
  91   case GeomAbs_Line:      return(ElCLib::LineValue(X,Axis.XAxis()));
  92   case GeomAbs_Ellipse:   return(ElCLib::EllipseValue(X,Axis,Elips_a,Elips_b));
  93   case GeomAbs_Circle:    return(ElCLib::CircleValue(X,Axis,Circle_r));
  94   case GeomAbs_Parabola:  return(ElCLib::ParabolaValue(X,Axis,Parab_f));
  95   case GeomAbs_Hyperbola: return(ElCLib::HyperbolaValue(X,Axis,Hypr_a,Hypr_b));
  96   default: { cout<<"### Erreur sur le  type de la courbe ###";
  97             return(gp_Pnt2d(0.0,0.0)); }
  98   }
  99 }
 100
 101 //----------------------------------------------------------------------
 102 void IntCurve_IConicTool::D1(const Standard_Real X,
 103                            gp_Pnt2d& Pt,
 104                            gp_Vec2d& Tan) const {
 105
 106   switch(type) {
 107   case GeomAbs_Line:     ElCLib::LineD1(X,Axis.XAxis(),Pt,Tan); break;
 108   case GeomAbs_Ellipse:     ElCLib::EllipseD1(X,Axis,Elips_a,Elips_b,Pt,Tan); break;
 109   case GeomAbs_Circle:     ElCLib::CircleD1(X,Axis,Circle_r,Pt,Tan); break;
 110   case GeomAbs_Parabola:     ElCLib::ParabolaD1(X,Axis,Parab_f,Pt,Tan); break;
 111   case GeomAbs_Hyperbola:     ElCLib::HyperbolaD1(X,Axis,Hypr_a,Hypr_b,Pt,Tan); break;
 112   default: { cout<<"### Erreur sur le  type de la courbe ###"; }
 113   }
 114 }
 115
 116 //----------------------------------------------------------------------
 117 void IntCurve_IConicTool::D2(const Standard_Real X,
 118                            gp_Pnt2d& Pt,
 119                            gp_Vec2d& Tan,
 120                            gp_Vec2d& Norm) const {
 121
 122   switch(type) {
 123   case GeomAbs_Line:     ElCLib::LineD1(X,Axis.XAxis(),Pt,Tan); Norm.SetCoord(0.0,0.0); break;
 124   case GeomAbs_Ellipse:     ElCLib::EllipseD2(X,Axis,Elips_a,Elips_b,Pt,Tan,Norm); break;
 125   case GeomAbs_Circle:     ElCLib::CircleD2(X,Axis,Circle_r,Pt,Tan,Norm); break;
 126   case GeomAbs_Parabola:     ElCLib::ParabolaD2(X,Axis,Parab_f,Pt,Tan,Norm); break;
 127   case GeomAbs_Hyperbola:     ElCLib::HyperbolaD2(X,Axis,Hypr_a,Hypr_b,Pt,Tan,Norm); break;
 128   default: { cout<<"### Erreur sur le  type de la courbe ###"; }
 129   }
 130 }
 131 //----------------------------------------------------------------------
 132 #define AN_ELIPS 0
 133 //----------------------------------------------------------------------
 134 Standard_Real IntCurve_IConicTool::Distance(const gp_Pnt2d& ThePoint) const {
 135
 136   switch(type) {
 137   case GeomAbs_Line:
 138     {
 139       return(Line_a*ThePoint.X()+Line_b*ThePoint.Y()+Line_c);
 140     }
 141
 142   case GeomAbs_Ellipse:
 143     {
 144 #if AN_ELIPS
 145       gp_Pnt2d P=ThePoint;
 146       P.Transform(Abs_To_Object);
 147       Standard_Real x=P.X();
 148       Standard_Real y2=P.Y() * P.Y();
 149       return(sqrt(y2+(x+Elips_c)*(x+Elips_c))
 150              +sqrt(y2+(x-Elips_c)*(x-Elips_c))-Elips_a-Elips_a);
 151 #else
 152       gp_Pnt2d P=ThePoint;
 153       P.Transform(Abs_To_Object);
 154       Standard_Real x=P.X();
 155       Standard_Real y=P.Y()*(Elips_a/Elips_b);
 156       Standard_Real d=sqrt(x*x+y*y)-Elips_a;
 157       return(d);
 158 #endif
 159     }
 160
 161   case GeomAbs_Circle:
 162     {
 163       Standard_Real Dx=Circle_x0-ThePoint.X();
 164       Standard_Real Dy=Circle_y0-ThePoint.Y();
 165       return(sqrt(Dx*Dx+Dy*Dy)-Circle_r);
 166     }
 167
 168   case GeomAbs_Parabola:
 169     {    //-- Distance(X,Y) = Y**2 - 2 P X
 170       gp_Pnt2d P=ThePoint;
 171       P.Transform(Abs_To_Object);
 172       return(P.Y()*P.Y()-Parab_2p*P.X());
 173     }
 174
 175   case GeomAbs_Hyperbola:
 176     { //-- Distance(X,Y) = (X/a)**2 - (Y/b)**2 -1
 177       //--                 pour x>0
 178       //--     -(Y/b)**2 - 1  sinon ??
 179       //--     avec un gradient avec x -> Abs(x)
 180       gp_Pnt2d P=ThePoint;
 181       P.Transform(Abs_To_Object);
 182       if(P.X()>0.0)
 183         return((P.X()*P.X())/Hypr_aa
 184                -(P.Y()*P.Y())/Hypr_bb -1.0);
 185       else
 186         return((-P.X()*P.X())/Hypr_aa
 187                -(P.Y()*P.Y())/Hypr_bb -1.0);
 188     }
 189   default: { cout<<"### Erreur sur le  type de la courbe ###";
 190             return(0.0); }
 191   }
 192 }
 193
 194
 195 gp_Vec2d IntCurve_IConicTool::GradDistance(const gp_Pnt2d& ThePoint) const {
 196
 197   switch(type) {
 198   case GeomAbs_Line: return(gp_Vec2d(Line_a,Line_b));
 199
 200   case GeomAbs_Circle: {
 201     gp_Pnt2d P=ThePoint;
 202     P.Transform(Abs_To_Object);
 203     Standard_Real Gradx=0.0;
 204     Standard_Real Grady=0.0;
 205     Standard_Real x=P.X();
 206     Standard_Real y=P.Y();
 207     Standard_Real temp1=sqrt(y*y+x*x);
 208     if(temp1) {
 209       Gradx=x/temp1;
 210       Grady=y/temp1;
 211     }
 212     gp_Vec2d Gradient(Gradx,Grady);
 213     Gradient.Transform(Object_To_Abs);
 214     return(Gradient);
 215   }
 216   case GeomAbs_Ellipse: {
 217 #if AN_ELIPS
 218     gp_Pnt2d P=ThePoint;
 219     P.Transform(Abs_To_Object);
 220     Standard_Real Gradx=0.0;
 221     Standard_Real Grady=0.0;
 222     Standard_Real x=P.X();
 223     Standard_Real y=P.Y();
 224     Standard_Real xmc=x-Elips_c;
 225     Standard_Real xpc=x+Elips_c;
 226     Standard_Real temp1=sqrt(y*y+xmc*xmc);
 227     Standard_Real temp2=sqrt(y*y+xpc*xpc);
 228     if(temp2) {
 229       Gradx=xpc/temp2;
 230       Grady=y/temp2;
 231     }
 232     if(temp1) {
 233       Gradx+=xmc/temp1;
 234       Grady+=y/temp1;
 235     }
 236     gp_Vec2d Gradient(Gradx,Grady);
 237     Gradient.Transform(Object_To_Abs);
 238     return(Gradient);
 239 #else
 240     gp_Pnt2d P=ThePoint;
 241     P.Transform(Abs_To_Object);
 242     Standard_Real Gradx=0.0;
 243     Standard_Real Grady=0.0;
 244     Standard_Real x=P.X();
 245     Standard_Real y=P.Y()*(Elips_a/Elips_b);
 246     Standard_Real temp1=sqrt(y*y+x*x);
 247     if(temp1) {
 248       Gradx=x/temp1;
 249       Grady=(y*(Elips_a/Elips_b))/temp1;
 250     }
 251     gp_Vec2d Gradient(Gradx,Grady);
 252     Gradient.Transform(Object_To_Abs);
 253     return(Gradient);
 254 #endif
 255   }
 256
 257   case GeomAbs_Parabola: {    //-- Distance(X,Y) = Y**2 - 2 P X
 258     gp_Pnt2d P=ThePoint;
 259     P.Transform(Abs_To_Object);
 260     gp_Vec2d Gradient(-Parab_2p,P.Y()+P.Y());
 261     Gradient.Transform(Object_To_Abs);
 262     return(Gradient);
 263   }
 264   case GeomAbs_Hyperbola: { //-- Distance(X,Y) = (X/a)**2 - (Y/b)**2 -1
 265     gp_Pnt2d P=ThePoint;
 266     P.Transform(Abs_To_Object);
 267     //--### la Branche a X negatif doit ramener vers les X positifs
 268     gp_Vec2d Gradient(2.0*Abs(P.X())/Hypr_aa,-2.0*P.Y()/Hypr_bb);
 269     Gradient.Transform(Object_To_Abs);
 270     return(Gradient);
 271   }
 272   default: { cout<<"### Erreur sur le  type de la courbe ###";
 273             return(gp_Vec2d(0.0,0.0)); }
 274   }
 275 }
 276
 277
 278 Standard_Real IntCurve_IConicTool::FindParameter(const gp_Pnt2d& P) const {
 279
 280   Standard_Real Param=0;
 281
 282   switch(type) {
 283
 284   case GeomAbs_Line:
 285     Param=ElCLib::LineParameter(Axis.XAxis(),P);
 286     break;
 287
 288   case GeomAbs_Circle:
 289     Param=ElCLib::CircleParameter(Axis,P);
 290     if(Param<0.0) { Param+=M_PI+M_PI; }
 291     break;
 292
 293   case GeomAbs_Ellipse: {
 294     Param=ElCLib::EllipseParameter(Axis
 295                                    ,Elips_a
 296                                    ,Elips_b
 297                                    ,P);
 298     if (Param < 0.0) { Param+=M_PI+M_PI; }
 299     break;
 300   }
 301
 302   case GeomAbs_Parabola: {
 303     Param=ElCLib::ParabolaParameter(Axis,P);
 304     break;
 305   }
 306   case GeomAbs_Hyperbola: {
 307     Param=ElCLib::HyperbolaParameter(Axis
 308                                      ,Hypr_a
 309                                      ,Hypr_b
 310                                      ,P);
 311     break;
 312   }
 313 #ifndef DEB
 314   default:
 315     break;
 316 #endif
 317   }
 318
 319   return(Param);
 320 }
 321
 322