src/gp/gp_Hypr.lxx

   1 // Copyright (c) 1995-1999 Matra Datavision
   2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   3 //
   4 // This file is part of Open CASCADE Technology software library.
   5 //
   6 // This library is free software; you can redistribute it and/or modify it under
   7 // the terms of the GNU Lesser General Public License version 2.1 as published
   8 // by the Free Software Foundation, with special exception defined in the file
   9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  10 // distribution for complete text of the license and disclaimer of any warranty.
  11 //
  12 // Alternatively, this file may be used under the terms of Open CASCADE
  13 // commercial license or contractual agreement.
  14
  15 #include <gp.hxx>
  16 #include <Standard_DomainError.hxx>
  17 #include <Standard_ConstructionError.hxx>
  18
  19 inline gp_Hypr::gp_Hypr () :
  20 majorRadius(RealLast()),
  21 minorRadius(RealFirst())
  22 { }
  23
  24 inline gp_Hypr::gp_Hypr (const gp_Ax2& A2,
  25                          const Standard_Real MajorRadius,
  26                          const Standard_Real MinorRadius):
  27                          pos(A2),
  28                          majorRadius(MajorRadius),
  29                          minorRadius(MinorRadius)
  30 {
  31   Standard_ConstructionError_Raise_if
  32     (MinorRadius < 0.0 || MajorRadius < 0.0,"");
  33 }
  34
  35 inline void gp_Hypr::SetAxis (const gp_Ax1& A1)
  36 { pos.SetAxis (A1); }
  37
  38 inline void gp_Hypr::SetLocation (const gp_Pnt& P)
  39 { pos = gp_Ax2 (P, pos.Direction(), pos.XDirection()); }
  40
  41 inline void gp_Hypr::SetMajorRadius (const Standard_Real R)
  42 {
  43   Standard_ConstructionError_Raise_if(R < 0.0,"");
  44   majorRadius = R;
  45 }
  46
  47 inline void gp_Hypr::SetMinorRadius (const Standard_Real R)
  48 {
  49   Standard_ConstructionError_Raise_if(R < 0.0,"");
  50   minorRadius = R;
  51 }
  52
  53 inline void gp_Hypr::SetPosition (const gp_Ax2& A2)
  54 { pos = A2; }
  55
  56 inline gp_Ax1 gp_Hypr::Asymptote1 () const
  57 {
  58   Standard_ConstructionError_Raise_if
  59     (majorRadius <= gp::Resolution(), "");
  60   gp_Vec V1 = gp_Vec (pos.YDirection());
  61   V1.Multiply (minorRadius / majorRadius);
  62   gp_Vec V = gp_Vec (pos.XDirection());
  63   V.Add (V1);
  64   return  gp_Ax1(pos.Location(), gp_Dir(V));
  65 }
  66
  67 inline gp_Ax1 gp_Hypr::Asymptote2 () const
  68 {
  69   Standard_ConstructionError_Raise_if (majorRadius <= gp::Resolution(), "");
  70   gp_Vec V1 = gp_Vec (pos.YDirection());
  71   V1.Multiply (-minorRadius / majorRadius);
  72   gp_Vec V = gp_Vec (pos.XDirection());
  73   V.Add (V1);
  74   return  gp_Ax1( pos.Location(), gp_Dir(V));
  75 }
  76
  77 inline const gp_Ax1& gp_Hypr::Axis () const
  78 { return pos.Axis(); }
  79
  80 inline gp_Hypr gp_Hypr::ConjugateBranch1 () const
  81 {
  82   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), pos.YDirection()),
  83                   minorRadius,
  84                   majorRadius);
  85 }
  86
  87 inline gp_Hypr gp_Hypr::ConjugateBranch2 () const
  88 {
  89   gp_Dir D = pos.YDirection();
  90   D.Reverse ();
  91   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), D),
  92                   minorRadius,
  93                   majorRadius);
  94 }
  95
  96 inline gp_Ax1 gp_Hypr::Directrix1 () const
  97 {
  98   Standard_Real E = Eccentricity();
  99   gp_XYZ Orig = pos.XDirection().XYZ();
 100   Orig.Multiply (majorRadius/E);
 101   Orig.Add (pos.Location().XYZ());
 102   return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
 103 }
 104
 105 inline gp_Ax1 gp_Hypr::Directrix2 () const
 106 {
 107   Standard_Real E = Eccentricity();
 108   gp_XYZ Orig = pos.XDirection().XYZ();
 109   Orig.Multiply (-majorRadius/E);
 110   Orig.Add (pos.Location().XYZ());
 111   return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
 112 }
 113
 114 inline Standard_Real gp_Hypr::Eccentricity () const
 115 {
 116   Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(), "");
 117   return sqrt(majorRadius * majorRadius +
 118               minorRadius * minorRadius) / majorRadius;
 119 }
 120
 121 inline Standard_Real gp_Hypr::Focal () const
 122 {
 123   return 2.0 * sqrt(majorRadius * majorRadius +
 124                     minorRadius * minorRadius);
 125 }
 126
 127 inline gp_Pnt gp_Hypr::Focus1 () const
 128 {
 129   Standard_Real C = sqrt(majorRadius * majorRadius +
 130                          minorRadius * minorRadius);
 131   const gp_Pnt& PP = pos.Location  ();
 132   const gp_Dir& DD = pos.XDirection();
 133   return gp_Pnt (PP.X() + C * DD.X(),
 134                  PP.Y() + C * DD.Y(),
 135                  PP.Z() + C * DD.Z());
 136 }
 137
 138 inline gp_Pnt gp_Hypr::Focus2 () const
 139 {
 140   Standard_Real C = sqrt(majorRadius * majorRadius +
 141                          minorRadius * minorRadius);
 142   const gp_Pnt& PP = pos.Location  ();
 143   const gp_Dir& DD = pos.XDirection();
 144   return gp_Pnt (PP.X() - C * DD.X(),
 145                  PP.Y() - C * DD.Y(),
 146                  PP.Z() - C * DD.Z());
 147 }
 148
 149 inline const gp_Pnt& gp_Hypr::Location () const
 150 { return pos.Location(); }
 151
 152 inline   Standard_Real gp_Hypr::MajorRadius() const
 153 { return majorRadius; }
 154
 155 inline   Standard_Real gp_Hypr::MinorRadius() const
 156 { return minorRadius; }
 157
 158 inline gp_Hypr gp_Hypr::OtherBranch () const
 159 {
 160   gp_Dir D = pos.XDirection ();
 161   D.Reverse ();
 162   return gp_Hypr (gp_Ax2(pos.Location(), pos.Direction(), D),
 163                   majorRadius, minorRadius);
 164 }
 165
 166 inline Standard_Real gp_Hypr::Parameter() const
 167 {
 168   Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(), "");
 169   return (minorRadius * minorRadius) / majorRadius;
 170 }
 171
 172 inline   const gp_Ax2& gp_Hypr::Position() const
 173 { return pos; }
 174
 175 inline gp_Ax1 gp_Hypr::XAxis () const
 176 {return gp_Ax1 (pos.Location(), pos.XDirection());}
 177
 178 inline gp_Ax1 gp_Hypr::YAxis () const
 179 {return gp_Ax1 (pos.Location(), pos.YDirection());}
 180
 181 inline void gp_Hypr::Rotate (const gp_Ax1& A1,
 182                              const Standard_Real Ang)
 183 { pos.Rotate(A1, Ang); }
 184
 185 inline gp_Hypr gp_Hypr::Rotated (const gp_Ax1& A1,
 186                                  const Standard_Real Ang) const
 187 {
 188   gp_Hypr H = *this;
 189   H.pos.Rotate(A1, Ang);
 190   return H;
 191 }
 192
 193 inline void gp_Hypr::Scale (const gp_Pnt& P,
 194                             const Standard_Real S)
 195 {
 196   majorRadius *= S;
 197   if (majorRadius < 0) majorRadius = - majorRadius;
 198   minorRadius *= S;
 199   if (minorRadius < 0) minorRadius = - minorRadius;
 200   pos.Scale(P, S);
 201 }
 202
 203 inline gp_Hypr gp_Hypr::Scaled (const gp_Pnt& P,
 204                                 const Standard_Real S) const
 205 {
 206   gp_Hypr H = *this;
 207   H.majorRadius *= S;
 208   if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
 209   H.minorRadius *= S;
 210   if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
 211   H.pos.Scale(P, S);
 212   return H;
 213 }
 214
 215 inline void gp_Hypr::Transform (const gp_Trsf& T)
 216 {
 217   majorRadius *= T.ScaleFactor();
 218   if (majorRadius < 0) majorRadius = - majorRadius;
 219   minorRadius *= T.ScaleFactor();
 220   if (minorRadius < 0) minorRadius = - minorRadius;
 221   pos.Transform(T);
 222 }
 223
 224 inline gp_Hypr gp_Hypr::Transformed (const gp_Trsf& T) const
 225 {
 226   gp_Hypr H = *this;
 227   H.majorRadius *= T.ScaleFactor();
 228   if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
 229   H.minorRadius *= T.ScaleFactor();
 230   if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
 231   H.pos.Transform(T);
 232   return H;
 233 }
 234
 235 inline void gp_Hypr::Translate (const gp_Vec& V)
 236 { pos.Translate(V); }
 237
 238 inline gp_Hypr gp_Hypr::Translated (const gp_Vec& V) const
 239 {
 240   gp_Hypr H = *this;
 241   H.pos.Translate(V);
 242   return H;
 243 }
 244
 245 inline void gp_Hypr::Translate (const gp_Pnt& P1,
 246                                 const gp_Pnt& P2)
 247 {pos.Translate(P1,P2);}
 248
 249 inline gp_Hypr gp_Hypr::Translated (const gp_Pnt& P1,
 250                                     const gp_Pnt& P2) const
 251 {
 252   gp_Hypr H = *this;
 253   H.pos.Translate(P1, P2);
 254   return H;
 255 }
 256