0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_Parab2d.hxx
index c322f04..a16b61e 100644 (file)
 #ifndef _gp_Parab2d_HeaderFile
 #define _gp_Parab2d_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
 #include <gp_Ax22d.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Boolean.hxx>
 #include <gp_Ax2d.hxx>
 #include <gp_Pnt2d.hxx>
-class Standard_ConstructionError;
-class gp_Ax2d;
-class gp_Ax22d;
-class gp_Pnt2d;
-class gp_Trsf2d;
-class gp_Vec2d;
-
+#include <Standard_ConstructionError.hxx>
 
 //! Describes a parabola in the plane (2D space).
 //! A parabola is defined by its focal length (that is, the
@@ -62,10 +50,10 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an indefinite parabola.
-  gp_Parab2d();
-  
+  gp_Parab2d()
+  : focalLength (RealLast())
+  {}
 
   //! Creates a parabola with its vertex point, its axis of symmetry
   //! ("XAxis") and its focal length.
@@ -75,18 +63,26 @@ public:
   //! Warnings : It is possible to have FocalLength = 0. In this case,
   //! the parabola looks like a line, which is parallel to the symmetry-axis.
   //! Raises ConstructionError if FocalLength < 0.0
-  gp_Parab2d(const gp_Ax2d& theMirrorAxis,
-             const Standard_Real theFocalLength,
-             const Standard_Boolean theSense = Standard_True);
-  
+  gp_Parab2d (const gp_Ax2d& theMirrorAxis,
+              const Standard_Real theFocalLength,
+              const Standard_Boolean theSense = Standard_True)
+  : focalLength (theFocalLength)
+  {
+    pos = gp_Ax22d (theMirrorAxis, theSense);
+    Standard_ConstructionError_Raise_if (theFocalLength < 0.0, "gp_Parab2d() - focal length should be >= 0");
+  }
 
   //! Creates a parabola with its vertex point, its axis of symmetry
   //! ("XAxis"), correspond Y-axis and its focal length.
   //! Warnings : It is possible to have FocalLength = 0. In this case,
   //! the parabola looks like a line, which is parallel to the symmetry-axis.
   //! Raises ConstructionError if Focal < 0.0
-  gp_Parab2d(const gp_Ax22d& theAxes, const Standard_Real theFocalLength);
-  
+  gp_Parab2d (const gp_Ax22d& theAxes, const Standard_Real theFocalLength)
+  : pos (theAxes),
+    focalLength (theFocalLength)
+  {
+    Standard_ConstructionError_Raise_if (theFocalLength < 0.0, "gp_Parab2d() - focal length should be >= 0");
+  }
 
   //! Creates a parabola with the directrix and the focus point.
   //! Y-axis of the parabola (in User Coordinate System - UCS) is
@@ -99,42 +95,42 @@ public:
   //! by theSense parameter. If theSense == TRUE (by default) then right-handed
   //! coordinate system is used, otherwise - left-handed. Result parabola will look
   //! like a line, which is perpendicular to the directrix.
-  Standard_EXPORT gp_Parab2d(const gp_Ax2d& theDirectrix,
-                             const gp_Pnt2d& theFocus,
-                             const Standard_Boolean theSense = Standard_True);
-  
+  Standard_EXPORT gp_Parab2d (const gp_Ax2d& theDirectrix,
+                              const gp_Pnt2d& theFocus,
+                              const Standard_Boolean theSense = Standard_True);
+
   //! Changes the focal distance of the parabola
-  //! Warnings : It is possible to have Focal = 0.
-  //! Raises ConstructionError if Focal < 0.0
-    void SetFocal (const Standard_Real Focal);
-  
+  //! Warnings : It is possible to have theFocal = 0.
+  //! Raises ConstructionError if theFocal < 0.0
+  void SetFocal (const Standard_Real theFocal)
+  {
+    Standard_ConstructionError_Raise_if (theFocal < 0.0, "gp_Parab2d::SetFocal() - focal length should be >= 0");
+    focalLength = theFocal;
+  }
 
   //! Changes the "Location" point of the parabola. It is the
   //! vertex of the parabola.
-    void SetLocation (const gp_Pnt2d& P);
-  
+  void SetLocation (const gp_Pnt2d& theP) { pos.SetLocation (theP); }
+
   //! Modifies this parabola, by redefining its local coordinate system so that
   //! its origin and "X Direction" become those of the axis
   //! MA. The "Y Direction" of the local coordinate system is
   //! then recomputed. The orientation of the local
   //! coordinate system is not modified.
-    void SetMirrorAxis (const gp_Ax2d& A);
-  
+  void SetMirrorAxis (const gp_Ax2d& theA) { pos.SetXAxis (theA); }
 
   //! Changes the local coordinate system of the parabola.
   //! The "Location" point of A becomes the vertex of the parabola.
-    void SetAxis (const gp_Ax22d& A);
-  
+  void SetAxis (const gp_Ax22d& theA) { pos.SetAxis (theA); }
 
   //! Computes the coefficients of the implicit equation of the parabola
   //! (in WCS - World Coordinate System).
   //! @code
-  //! A * (X**2) + B * (Y**2) + 2*C*(X*Y) + 2*D*X + 2*E*Y + F = 0.
+  //! theA * (X**2) + theB * (Y**2) + 2*theC*(X*Y) + 2*theD*X + 2*theE*Y + theF = 0.
   //! @endcode
-  Standard_EXPORT void Coefficients (Standard_Real& A, Standard_Real& B,
-                                     Standard_Real& C, Standard_Real& D,
-                                     Standard_Real& E, Standard_Real& F) const;
-  
+  Standard_EXPORT void Coefficients (Standard_Real& theA, Standard_Real& theB,
+                                     Standard_Real& theC, Standard_Real& theD,
+                                     Standard_Real& theE, Standard_Real& theF) const;
 
   //! Computes the directrix of the parabola.
   //! The directrix is:
@@ -144,36 +140,40 @@ public:
   //! at a distance from the apex which is equal to the focal  length of this parabola.
   //! The directrix is returned as an axis (a gp_Ax2d object),
   //! the origin of which is situated on the "X Axis" of this parabola.
-    gp_Ax2d Directrix() const;
-  
+  gp_Ax2d Directrix() const;
 
   //! Returns the distance between the vertex and the focus
   //! of the parabola.
-    Standard_Real Focal() const;
-  
+  Standard_Real Focal() const { return focalLength; }
+
   //! Returns the focus of the parabola.
-    gp_Pnt2d Focus() const;
-  
+  gp_Pnt2d Focus() const
+  {
+    return gp_Pnt2d (pos.Location().X() + focalLength * pos.XDirection().X(),
+                     pos.Location().Y() + focalLength * pos.XDirection().Y());
+  }
+
   //! Returns the vertex of the parabola.
-    gp_Pnt2d Location() const;
-  
+  gp_Pnt2d Location() const { return pos.Location(); }
 
   //! Returns the symmetry axis of the parabola.
   //! The "Location" point of this axis is the vertex of the parabola.
-    gp_Ax2d MirrorAxis() const;
-  
+  gp_Ax2d MirrorAxis() const { return pos.XAxis(); }
 
   //! Returns the local coordinate system of the parabola.
   //! The "Location" point of this axis is the vertex of the parabola.
-    gp_Ax22d Axis() const;
-  
+  gp_Ax22d Axis() const { return pos; }
 
   //! Returns the distance between the focus and the
   //! directrix of the parabola.
-    Standard_Real Parameter() const;
-  
-    void Reverse();
-  
+  Standard_Real Parameter() const { return 2.0 * focalLength; }
+
+  void Reverse()
+  {
+    gp_Dir2d aTemp = pos.YDirection();
+    aTemp.Reverse();
+    pos.SetAxis (gp_Ax22d (pos.Location(), pos.XDirection(), aTemp));
+  }
 
   //! Reverses the orientation of the local coordinate system
   //! of this parabola (the "Y Direction" is reversed).
@@ -181,84 +181,161 @@ public:
   //! Note:
   //! -   Reverse assigns the result to this parabola, while
   //! -   Reversed creates a new one.
-    Standard_NODISCARD gp_Parab2d Reversed() const;
-  
+  Standard_NODISCARD gp_Parab2d Reversed() const;
+
   //! Returns true if the local coordinate system is direct
   //! and false in the other case.
-    Standard_Boolean IsDirect() const;
-  
-  Standard_EXPORT void Mirror (const gp_Pnt2d& P);
-  
+  Standard_Boolean IsDirect() const
+  {
+    return (pos.XDirection().Crossed (pos.YDirection())) >= 0.0;
+  }
+
+  Standard_EXPORT void Mirror (const gp_Pnt2d& theP);
 
   //! Performs the symmetrical transformation of a parabola with respect
-  //! to the point P which is the center of the symmetry
-  Standard_NODISCARD Standard_EXPORT gp_Parab2d Mirrored (const gp_Pnt2d& P) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2d& A);
-  
+  //! to the point theP which is the center of the symmetry
+  Standard_NODISCARD Standard_EXPORT gp_Parab2d Mirrored (const gp_Pnt2d& theP) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2d& theA);
 
   //! Performs the symmetrical transformation of a parabola with respect
   //! to an axis placement which is the axis of the symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Parab2d Mirrored (const gp_Ax2d& A) const;
-  
-    void Rotate (const gp_Pnt2d& P, const Standard_Real Ang);
-  
-
-  //! Rotates a parabola. P is the center of the rotation.
-  //! Ang is the angular value of the rotation in radians.
-    Standard_NODISCARD gp_Parab2d Rotated (const gp_Pnt2d& P, const Standard_Real Ang) const;
-  
-    void Scale (const gp_Pnt2d& P, const Standard_Real S);
-  
-
-  //! Scales a parabola. S is the scaling value.
-  //! If S is negative the direction of the symmetry axis
-  //! "XAxis" is reversed and the direction of the "YAxis" too.
-    Standard_NODISCARD gp_Parab2d Scaled (const gp_Pnt2d& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf2d& T);
-  
-
-  //! Transforms an parabola with the transformation T from class Trsf2d.
-    Standard_NODISCARD gp_Parab2d Transformed (const gp_Trsf2d& T) const;
-  
-    void Translate (const gp_Vec2d& V);
-  
-
-  //! Translates a parabola in the direction of the vector V.
-  //! The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Parab2d Translated (const gp_Vec2d& V) const;
-  
-    void Translate (const gp_Pnt2d& P1, const gp_Pnt2d& P2);
-  
-
-  //! Translates a parabola from the point P1 to the point P2.
-    Standard_NODISCARD gp_Parab2d Translated (const gp_Pnt2d& P1, const gp_Pnt2d& P2) const;
+  Standard_NODISCARD Standard_EXPORT gp_Parab2d Mirrored (const gp_Ax2d& theA) const;
 
+  void Rotate (const gp_Pnt2d& theP, const Standard_Real theAng) { pos.Rotate (theP, theAng); }
 
+  //! Rotates a parabola. theP is the center of the rotation.
+  //! theAng is the angular value of the rotation in radians.
+  Standard_NODISCARD gp_Parab2d Rotated (const gp_Pnt2d& theP, const Standard_Real theAng) const
+  {
+    gp_Parab2d aPrb = *this;
+    aPrb.pos.Rotate (theP, theAng);
+    return aPrb;
+  }
 
+  void Scale (const gp_Pnt2d& theP, const Standard_Real theS);
 
-protected:
+  //! Scales a parabola. theS is the scaling value.
+  //! If theS is negative the direction of the symmetry axis
+  //! "XAxis" is reversed and the direction of the "YAxis" too.
+  Standard_NODISCARD gp_Parab2d Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const;
 
+  void Transform (const gp_Trsf2d& theT);
 
+  //! Transforms an parabola with the transformation theT from class Trsf2d.
+  Standard_NODISCARD gp_Parab2d Transformed (const gp_Trsf2d& theT) const;
 
+  void Translate (const gp_Vec2d& theV) { pos.Translate (theV); }
 
+  //! Translates a parabola in the direction of the vectorthe theV.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Parab2d Translated (const gp_Vec2d& theV) const
+  {
+    gp_Parab2d aPrb = *this;
+    aPrb.pos.Translate (theV);
+    return aPrb;
+  }
+
+  void Translate (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) { pos.Translate (theP1, theP2); }
+
+  //! Translates a parabola from the point theP1 to the point theP2.
+  Standard_NODISCARD gp_Parab2d Translated (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) const
+  {
+    gp_Parab2d aPrb = *this;
+    aPrb.pos.Translate (theP1, theP2);
+    return aPrb;
+  }
 
 private:
 
-
-
   gp_Ax22d pos;
   Standard_Real focalLength;
 
-
 };
 
-
-#include <gp_Parab2d.lxx>
-
-
-
-
+//=======================================================================
+//function : Directrix
+// purpose :
+//=======================================================================
+inline gp_Ax2d gp_Parab2d::Directrix() const
+{
+  gp_Pnt2d aP (pos.Location().X() - focalLength * pos.XDirection().X(),
+               pos.Location().Y() - focalLength * pos.XDirection().Y());
+  gp_Dir2d aV (pos.YDirection());
+  return gp_Ax2d (aP, aV);
+}
+
+//=======================================================================
+//function : Reversed
+// purpose :
+//=======================================================================
+inline gp_Parab2d gp_Parab2d::Reversed() const
+{
+  gp_Parab2d aP = *this;
+  gp_Dir2d aTemp = pos.YDirection();
+  aTemp.Reverse();
+  aP.pos.SetAxis (gp_Ax22d (pos.Location(), pos.XDirection(), aTemp));
+  return aP;
+}
+
+//=======================================================================
+//function : Scale
+// purpose :
+//=======================================================================
+inline void gp_Parab2d::Scale (const gp_Pnt2d& theP, const Standard_Real theS)
+{
+  focalLength *= theS;
+  if (focalLength < 0)
+  {
+    focalLength = -focalLength;
+  }
+  pos.Scale (theP, theS);
+}
+
+//=======================================================================
+//function : Scaled
+// purpose :
+//=======================================================================
+inline gp_Parab2d gp_Parab2d::Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const
+{
+  gp_Parab2d aPrb = *this;
+  aPrb.focalLength *= theS;
+  if (aPrb.focalLength < 0)
+  {
+    aPrb.focalLength = -aPrb.focalLength;
+  }
+  aPrb.pos.Scale (theP, theS);
+  return aPrb;
+}
+
+//=======================================================================
+//function : Transform
+// purpose :
+//=======================================================================
+inline void gp_Parab2d::Transform (const gp_Trsf2d& theT)
+{
+  focalLength *= theT.ScaleFactor();
+  if (focalLength < 0)
+  {
+    focalLength = -focalLength;
+  }
+  pos.Transform (theT);
+}
+
+//=======================================================================
+//function : Transformed
+// purpose :
+//=======================================================================
+inline gp_Parab2d gp_Parab2d::Transformed (const gp_Trsf2d& theT) const
+{
+  gp_Parab2d aPrb = *this;
+  aPrb.focalLength *= theT.ScaleFactor();
+  if (aPrb.focalLength < 0)
+  {
+    aPrb.focalLength = -aPrb.focalLength;
+  }
+  aPrb.pos.Transform (theT);
+  return aPrb;
+}
 
 #endif // _gp_Parab2d_HeaderFile