0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
authormkrylova <mkrylova@opencascade.com>
Wed, 17 Feb 2021 10:49:32 +0000 (13:49 +0300)
committerbugmaster <bugmaster@opencascade.com>
Thu, 3 Jun 2021 15:02:58 +0000 (18:02 +0300)
- merged .lxx files into header files within Package gp
- fixed code style

115 files changed:
src/DsgPrs/DsgPrs.hxx
src/IntAna/IntAna_Curve.hxx
src/PrsDim/PrsDim.hxx
src/PrsDim/PrsDim_Dimension.hxx
src/PrsDim/PrsDim_FixRelation.hxx
src/StdPrs/StdPrs_Isolines.hxx
src/gp/FILES
src/gp/gp.cxx
src/gp/gp.hxx
src/gp/gp.lxx [deleted file]
src/gp/gp_Ax1.cxx
src/gp/gp_Ax1.hxx
src/gp/gp_Ax1.lxx [deleted file]
src/gp/gp_Ax2.cxx
src/gp/gp_Ax2.hxx
src/gp/gp_Ax2.lxx [deleted file]
src/gp/gp_Ax22d.cxx
src/gp/gp_Ax22d.hxx
src/gp/gp_Ax22d.lxx [deleted file]
src/gp/gp_Ax2d.cxx
src/gp/gp_Ax2d.hxx
src/gp/gp_Ax2d.lxx [deleted file]
src/gp/gp_Ax3.cxx
src/gp/gp_Ax3.hxx
src/gp/gp_Ax3.lxx [deleted file]
src/gp/gp_Circ.cxx
src/gp/gp_Circ.hxx
src/gp/gp_Circ.lxx [deleted file]
src/gp/gp_Circ2d.cxx
src/gp/gp_Circ2d.hxx
src/gp/gp_Circ2d.lxx [deleted file]
src/gp/gp_Cone.cxx
src/gp/gp_Cone.hxx
src/gp/gp_Cone.lxx [deleted file]
src/gp/gp_Cylinder.cxx
src/gp/gp_Cylinder.hxx
src/gp/gp_Cylinder.lxx [deleted file]
src/gp/gp_Dir.cxx
src/gp/gp_Dir.hxx
src/gp/gp_Dir.lxx [deleted file]
src/gp/gp_Dir2d.cxx
src/gp/gp_Dir2d.hxx
src/gp/gp_Dir2d.lxx [deleted file]
src/gp/gp_Elips.cxx
src/gp/gp_Elips.hxx
src/gp/gp_Elips.lxx [deleted file]
src/gp/gp_Elips2d.cxx
src/gp/gp_Elips2d.hxx
src/gp/gp_Elips2d.lxx [deleted file]
src/gp/gp_GTrsf.cxx
src/gp/gp_GTrsf.hxx
src/gp/gp_GTrsf.lxx [deleted file]
src/gp/gp_GTrsf2d.cxx
src/gp/gp_GTrsf2d.hxx
src/gp/gp_GTrsf2d.lxx [deleted file]
src/gp/gp_Hypr.cxx
src/gp/gp_Hypr.hxx
src/gp/gp_Hypr.lxx [deleted file]
src/gp/gp_Hypr2d.cxx
src/gp/gp_Hypr2d.hxx
src/gp/gp_Hypr2d.lxx [deleted file]
src/gp/gp_Lin.cxx
src/gp/gp_Lin.hxx
src/gp/gp_Lin.lxx [deleted file]
src/gp/gp_Lin2d.cxx
src/gp/gp_Lin2d.hxx
src/gp/gp_Lin2d.lxx [deleted file]
src/gp/gp_Mat.cxx
src/gp/gp_Mat.hxx
src/gp/gp_Mat.lxx [deleted file]
src/gp/gp_Mat2d.cxx
src/gp/gp_Mat2d.hxx
src/gp/gp_Mat2d.lxx [deleted file]
src/gp/gp_Parab.cxx
src/gp/gp_Parab.hxx
src/gp/gp_Parab.lxx [deleted file]
src/gp/gp_Parab2d.cxx
src/gp/gp_Parab2d.hxx
src/gp/gp_Parab2d.lxx [deleted file]
src/gp/gp_Pln.cxx
src/gp/gp_Pln.hxx
src/gp/gp_Pln.lxx [deleted file]
src/gp/gp_Pnt.cxx
src/gp/gp_Pnt.hxx
src/gp/gp_Pnt.lxx [deleted file]
src/gp/gp_Pnt2d.cxx
src/gp/gp_Pnt2d.hxx
src/gp/gp_Pnt2d.lxx [deleted file]
src/gp/gp_Quaternion.cxx
src/gp/gp_Quaternion.hxx
src/gp/gp_Quaternion.lxx [deleted file]
src/gp/gp_Sphere.cxx
src/gp/gp_Sphere.hxx
src/gp/gp_Sphere.lxx [deleted file]
src/gp/gp_Torus.cxx
src/gp/gp_Torus.hxx
src/gp/gp_Torus.lxx [deleted file]
src/gp/gp_Trsf.cxx
src/gp/gp_Trsf.hxx
src/gp/gp_Trsf.lxx [deleted file]
src/gp/gp_Trsf2d.cxx
src/gp/gp_Trsf2d.hxx
src/gp/gp_Trsf2d.lxx [deleted file]
src/gp/gp_Vec.cxx
src/gp/gp_Vec.hxx
src/gp/gp_Vec.lxx [deleted file]
src/gp/gp_Vec2d.cxx
src/gp/gp_Vec2d.hxx
src/gp/gp_Vec2d.lxx [deleted file]
src/gp/gp_XY.cxx
src/gp/gp_XY.hxx
src/gp/gp_XY.lxx [deleted file]
src/gp/gp_XYZ.cxx
src/gp/gp_XYZ.hxx
src/gp/gp_XYZ.lxx [deleted file]

index 06cc1f2..0d8dc44 100644 (file)
@@ -20,6 +20,8 @@
 #include <DsgPrs_ArrowSide.hxx>
 #include <gp_Dir.hxx>
 #include <gp_Pnt.hxx>
+#include <gp_Circ.hxx>
+#include <gp_Elips.hxx>
 #include <Prs3d_Presentation.hxx>
 
 class Geom_Curve;
index 9aa08ba..4a3d35d 100644 (file)
@@ -23,6 +23,8 @@
 
 #include <GeomAbs_SurfaceType.hxx>
 #include <gp_Ax3.hxx>
+#include <gp_Cone.hxx>
+#include <gp_Cylinder.hxx>
 #include <TColStd_ListOfReal.hxx>
 
 //! Definition of a parametric Curve which is the result
index c865cb7..f272c89 100644 (file)
@@ -21,6 +21,7 @@
 #include <Aspect_TypeOfLine.hxx>
 #include <Aspect_TypeOfMarker.hxx>
 #include <gp_Dir.hxx>
+#include <gp_Elips.hxx>
 #include <gp_Pnt.hxx>
 #include <Quantity_NameOfColor.hxx>
 #include <Prs3d_Drawer.hxx>
index bc2047b..13bf0c6 100644 (file)
@@ -24,6 +24,7 @@
 #include <PrsDim_KindOfDimension.hxx>
 #include <PrsDim_KindOfSurface.hxx>
 #include <Geom_Curve.hxx>
+#include <gp_Circ.hxx>
 #include <gp_Pln.hxx>
 #include <Prs3d_ArrowAspect.hxx>
 #include <Prs3d_DimensionAspect.hxx>
index dcb7b58..4de0383 100644 (file)
@@ -17,6 +17,8 @@
 #ifndef _PrsDim_FixRelation_HeaderFile
 #define _PrsDim_FixRelation_HeaderFile
 
+#include <gp_Lin.hxx>
+#include <gp_Circ.hxx>
 #include <TopoDS_Wire.hxx>
 #include <PrsDim_Relation.hxx>
 
index 244c296..ab3f5f5 100644 (file)
@@ -18,6 +18,7 @@
 
 #include <BRepAdaptor_Surface.hxx>
 #include <Geom_Surface.hxx>
+#include <gp_Lin2d.hxx>
 #include <Prs3d_Drawer.hxx>
 #include <Prs3d_Presentation.hxx>
 #include <Prs3d_LineAspect.hxx>
index 02ead9c..06e80cf 100644 (file)
 gp.cxx
 gp.hxx
-gp.lxx
 gp_Ax1.cxx
 gp_Ax1.hxx
-gp_Ax1.lxx
 gp_Ax2.cxx
 gp_Ax2.hxx
-gp_Ax2.lxx
 gp_Ax2d.cxx
 gp_Ax2d.hxx
-gp_Ax2d.lxx
 gp_Ax3.cxx
 gp_Ax3.hxx
-gp_Ax3.lxx
 gp_Ax22d.cxx
 gp_Ax22d.hxx
-gp_Ax22d.lxx
 gp_Circ.cxx
 gp_Circ.hxx
-gp_Circ.lxx
 gp_Circ2d.cxx
 gp_Circ2d.hxx
-gp_Circ2d.lxx
 gp_Cone.cxx
 gp_Cone.hxx
-gp_Cone.lxx
 gp_Cylinder.cxx
 gp_Cylinder.hxx
-gp_Cylinder.lxx
 gp_Dir.cxx
 gp_Dir.hxx
-gp_Dir.lxx
 gp_Dir2d.cxx
 gp_Dir2d.hxx
-gp_Dir2d.lxx
 gp_Elips.cxx
 gp_Elips.hxx
-gp_Elips.lxx
 gp_Elips2d.cxx
 gp_Elips2d.hxx
-gp_Elips2d.lxx
 gp_EulerSequence.hxx
 gp_GTrsf.cxx
 gp_GTrsf.hxx
-gp_GTrsf.lxx
 gp_GTrsf2d.cxx
 gp_GTrsf2d.hxx
-gp_GTrsf2d.lxx
 gp_Hypr.cxx
 gp_Hypr.hxx
-gp_Hypr.lxx
 gp_Hypr2d.cxx
 gp_Hypr2d.hxx
-gp_Hypr2d.lxx
 gp_Lin.cxx
 gp_Lin.hxx
-gp_Lin.lxx
 gp_Lin2d.cxx
 gp_Lin2d.hxx
-gp_Lin2d.lxx
 gp_Mat.cxx
 gp_Mat.hxx
-gp_Mat.lxx
 gp_Mat2d.cxx
 gp_Mat2d.hxx
-gp_Mat2d.lxx
 gp_Parab.cxx
 gp_Parab.hxx
-gp_Parab.lxx
 gp_Parab2d.cxx
 gp_Parab2d.hxx
-gp_Parab2d.lxx
 gp_Pln.cxx
 gp_Pln.hxx
-gp_Pln.lxx
 gp_Pnt.cxx
 gp_Pnt.hxx
-gp_Pnt.lxx
 gp_Pnt2d.cxx
 gp_Pnt2d.hxx
-gp_Pnt2d.lxx
 gp_Quaternion.cxx
 gp_Quaternion.hxx
-gp_Quaternion.lxx
 gp_QuaternionNLerp.hxx
 gp_QuaternionSLerp.hxx
 gp_Sphere.cxx
 gp_Sphere.hxx
-gp_Sphere.lxx
 gp_Torus.cxx
 gp_Torus.hxx
-gp_Torus.lxx
 gp_Trsf.cxx
 gp_Trsf.hxx
-gp_Trsf.lxx
 gp_Trsf2d.cxx
 gp_Trsf2d.hxx
-gp_Trsf2d.lxx
 gp_TrsfForm.hxx
 gp_TrsfNLerp.hxx
 gp_Vec.cxx
 gp_Vec.hxx
-gp_Vec.lxx
 gp_Vec2d.cxx
 gp_Vec2d.hxx
-gp_Vec2d.lxx
 gp_Vec2f.hxx
 gp_Vec3f.hxx
 gp_VectorWithNullMagnitude.hxx
 gp_XY.cxx
 gp_XY.hxx
-gp_XY.lxx
 gp_XYZ.cxx
 gp_XYZ.hxx
-gp_XYZ.lxx
index e269c3b..96ebebc 100644 (file)
@@ -12,8 +12,8 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-
 #include <gp.hxx>
+
 #include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
 #include <gp_Ax2d.hxx>
index f6914eb..df23c4d 100644 (file)
@@ -20,8 +20,8 @@
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
-
 #include <Standard_Real.hxx>
+
 class gp_Pnt;
 class gp_Dir;
 class gp_Ax1;
@@ -29,43 +29,6 @@ class gp_Ax2;
 class gp_Pnt2d;
 class gp_Dir2d;
 class gp_Ax2d;
-class gp_XYZ;
-class gp_Mat;
-class gp_Quaternion;
-class gp_Trsf;
-class gp_GTrsf;
-class gp_Pnt;
-class gp_Vec;
-class gp_Dir;
-class gp_Ax1;
-class gp_Ax2;
-class gp_Ax3;
-class gp_Lin;
-class gp_Circ;
-class gp_Elips;
-class gp_Hypr;
-class gp_Parab;
-class gp_Pln;
-class gp_Cylinder;
-class gp_Sphere;
-class gp_Torus;
-class gp_Cone;
-class gp_XY;
-class gp_Mat2d;
-class gp_Trsf2d;
-class gp_GTrsf2d;
-class gp_Pnt2d;
-class gp_Vec2d;
-class gp_Dir2d;
-class gp_Ax2d;
-class gp_Ax22d;
-class gp_Lin2d;
-class gp_Circ2d;
-class gp_Elips2d;
-class gp_Hypr2d;
-class gp_Parab2d;
-
-
 
 //! The geometric processor package, called gp, provides an
 //! implementation of entities used  :
@@ -82,7 +45,6 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Method of package gp
   //!
   //! In geometric computations, defines the tolerance criterion
@@ -91,122 +53,65 @@ public:
   //! example, to avoid division by zero in geometric
   //! computations. In the documentation, tolerance criterion is
   //! always referred to as gp::Resolution().
-    static Standard_Real Resolution();
-  
+  static Standard_Real Resolution() { return RealSmall(); }
+
   //! Identifies a Cartesian point with coordinates X = Y = Z = 0.0.0
   Standard_EXPORT static const gp_Pnt& Origin();
-  
+
   //! Returns a unit vector with the combination (1,0,0)
   Standard_EXPORT static const gp_Dir& DX();
-  
+
   //! Returns a unit vector with the combination (0,1,0)
   Standard_EXPORT static const gp_Dir& DY();
-  
+
   //! Returns a unit vector with the combination (0,0,1)
   Standard_EXPORT static const gp_Dir& DZ();
-  
+
   //! Identifies an axis where its origin is Origin
   //! and its unit vector coordinates  X = 1.0,  Y = Z = 0.0
   Standard_EXPORT static const gp_Ax1& OX();
-  
+
   //! Identifies an axis where its origin is Origin
   //! and its unit vector coordinates Y = 1.0,  X = Z = 0.0
   Standard_EXPORT static const gp_Ax1& OY();
-  
+
   //! Identifies an axis where its origin is Origin
   //! and its unit vector coordinates Z = 1.0,  Y = X = 0.0
   Standard_EXPORT static const gp_Ax1& OZ();
-  
+
   //! Identifies a coordinate system where its origin is Origin,
   //! and its "main Direction" and "X Direction" coordinates
   //! Z = 1.0, X = Y =0.0 and X direction coordinates X = 1.0, Y = Z = 0.0
   Standard_EXPORT static const gp_Ax2& XOY();
-  
+
   //! Identifies a coordinate system where its origin is Origin,
   //! and its "main Direction" and "X Direction" coordinates
   //! Y = 1.0, X = Z =0.0 and X direction coordinates Z = 1.0, X = Y = 0.0
   Standard_EXPORT static const gp_Ax2& ZOX();
-  
+
   //! Identifies a coordinate system where its origin is Origin,
   //! and its "main Direction" and "X Direction" coordinates
   //! X = 1.0, Z = Y =0.0 and X direction coordinates Y = 1.0, X = Z = 0.0
   //! In 2D space
   Standard_EXPORT static const gp_Ax2& YOZ();
-  
+
   //! Identifies a Cartesian point with coordinates X = Y = 0.0
   Standard_EXPORT static const gp_Pnt2d& Origin2d();
-  
+
   //! Returns a unit vector with the combinations (1,0)
   Standard_EXPORT static const gp_Dir2d& DX2d();
-  
+
   //! Returns a unit vector with the combinations (0,1)
   Standard_EXPORT static const gp_Dir2d& DY2d();
-  
+
   //! Identifies an axis where its origin is Origin2d
   //! and its unit vector coordinates are: X = 1.0,  Y = 0.0
   Standard_EXPORT static const gp_Ax2d& OX2d();
-  
+
   //! Identifies an axis where its origin is Origin2d
   //! and its unit vector coordinates are Y = 1.0,  X = 0.0
   Standard_EXPORT static const gp_Ax2d& OY2d();
 
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-friend class gp_XYZ;
-friend class gp_Mat;
-friend class gp_Quaternion;
-friend class gp_Trsf;
-friend class gp_GTrsf;
-friend class gp_Pnt;
-friend class gp_Vec;
-friend class gp_Dir;
-friend class gp_Ax1;
-friend class gp_Ax2;
-friend class gp_Ax3;
-friend class gp_Lin;
-friend class gp_Circ;
-friend class gp_Elips;
-friend class gp_Hypr;
-friend class gp_Parab;
-friend class gp_Pln;
-friend class gp_Cylinder;
-friend class gp_Sphere;
-friend class gp_Torus;
-friend class gp_Cone;
-friend class gp_XY;
-friend class gp_Mat2d;
-friend class gp_Trsf2d;
-friend class gp_GTrsf2d;
-friend class gp_Pnt2d;
-friend class gp_Vec2d;
-friend class gp_Dir2d;
-friend class gp_Ax2d;
-friend class gp_Ax22d;
-friend class gp_Lin2d;
-friend class gp_Circ2d;
-friend class gp_Elips2d;
-friend class gp_Hypr2d;
-friend class gp_Parab2d;
-
 };
 
-
-#include <gp.lxx>
-
-
-
-
-
 #endif // _gp_HeaderFile
diff --git a/src/gp/gp.lxx b/src/gp/gp.lxx
deleted file mode 100644 (file)
index b67bb9a..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-// Created on: 1992-07-21
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-inline Standard_Real gp::Resolution  () 
-{ 
-  return RealSmall(); 
-}
index 19a5cfb..892b453 100644 (file)
@@ -19,9 +19,9 @@
 
 #define No_Standard_OutOfRange
 
+#include <gp_Ax1.hxx>
 
 #include <gp.hxx>
-#include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
 #include <gp_Dir.hxx>
 #include <gp_Pnt.hxx>
index 3efc5e1..4e92b97 100644 (file)
 #ifndef _gp_Ax1_HeaderFile
 #define _gp_Ax1_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
 #include <gp_Pnt.hxx>
 #include <gp_Dir.hxx>
-#include <Standard_Boolean.hxx>
-#include <Standard_Real.hxx>
-class gp_Pnt;
-class gp_Dir;
+
 class gp_Ax2;
 class gp_Trsf;
 class gp_Vec;
 
-
 //! Describes an axis in 3D space.
 //! An axis is defined by:
 //! -   its origin (also referred to as its "Location point"), and
@@ -48,27 +40,28 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an axis object representing Z axis of
   //! the reference coordinate system.
-    gp_Ax1();
-  
+  gp_Ax1()
+  : loc(0.,0.,0.), vdir(0.,0.,1.)
+  {}
 
   //! P is the location point and V is the direction of <me>.
-    gp_Ax1(const gp_Pnt& P, const gp_Dir& V);
-  
+  gp_Ax1 (const gp_Pnt& theP, const gp_Dir& theV)
+  : loc(theP), vdir (theV)
+  {}
+
   //! Assigns V as the "Direction"  of this axis.
-    void SetDirection (const gp_Dir& V);
-  
+  void SetDirection (const gp_Dir& theV) { vdir = theV; }
+
   //! Assigns  P as the origin of this axis.
-    void SetLocation (const gp_Pnt& P);
-  
+  void SetLocation (const gp_Pnt& theP) { loc = theP; }
+
   //! Returns the direction of <me>.
-    const gp_Dir& Direction() const;
-  
+  const gp_Dir& Direction() const { return vdir; }
+
   //! Returns the location point of <me>.
-    const gp_Pnt& Location() const;
-  
+  const gp_Pnt& Location() const { return loc; }
 
   //! Returns True if  :
   //! . the angle between <me> and <Other> is lower or equal
@@ -78,132 +71,157 @@ public:
   //! . the distance between <Other>.Location() and <me> is lower
   //! or equal to LinearTolerance.
   Standard_EXPORT Standard_Boolean IsCoaxial (const gp_Ax1& Other, const Standard_Real AngularTolerance, const Standard_Real LinearTolerance) const;
-  
 
-  //! Returns True if the direction of the <me> and <Other>
-  //! are normal to each other.
+  //! Returns True if the direction of this and another axis are normal to each other.
   //! That is, if the angle between the two axes is equal to Pi/2.
-  //! Note: the tolerance criterion is given by AngularTolerance..
-    Standard_Boolean IsNormal (const gp_Ax1& Other, const Standard_Real AngularTolerance) const;
-  
-
-  //! Returns True if the direction of <me> and <Other> are
-  //! parallel with opposite orientation. That is, if the angle
-  //! between the two axes is equal to Pi.
-  //! Note: the tolerance criterion is given by AngularTolerance.
-    Standard_Boolean IsOpposite (const gp_Ax1& Other, const Standard_Real AngularTolerance) const;
-  
-
-  //! Returns True if the direction of <me> and <Other> are
-  //! parallel with same orientation or opposite orientation. That
-  //! is, if the angle between the two axes is equal to 0 or Pi.
-  //! Note: the tolerance criterion is given by
-  //! AngularTolerance.
-    Standard_Boolean IsParallel (const gp_Ax1& Other, const Standard_Real AngularTolerance) const;
-  
-
-  //! Computes the angular value, in radians, between <me>.Direction() and
-  //! <Other>.Direction(). Returns the angle between 0 and 2*PI
-  //! radians.
-    Standard_Real Angle (const gp_Ax1& Other) const;
-  
-  //! Reverses the unit vector of this axis.
-  //! and  assigns the result to this axis.
-    void Reverse();
-  
+  //! Note: the tolerance criterion is given by theAngularTolerance.
+  Standard_Boolean IsNormal (const gp_Ax1& theOther, const Standard_Real theAngularTolerance) const
+  {
+    return vdir.IsNormal (theOther.vdir, theAngularTolerance);
+  }
+
+  //! Returns True if the direction of this and another axis are parallel with opposite orientation.
+  //! That is, if the angle between the two axes is equal to Pi.
+  //! Note: the tolerance criterion is given by theAngularTolerance.
+  Standard_Boolean IsOpposite (const gp_Ax1& theOther, const Standard_Real theAngularTolerance) const
+  {
+    return vdir.IsOpposite (theOther.vdir, theAngularTolerance);
+  }
+
+  //! Returns True if the direction of this and another axis are parallel with same orientation or opposite orientation.
+  //! That is, if the angle between the two axes is equal to 0 or Pi.
+  //! Note: the tolerance criterion is given by theAngularTolerance.
+  Standard_Boolean IsParallel (const gp_Ax1& theOther, const Standard_Real theAngularTolerance) const
+  {
+    return vdir.IsParallel(theOther.vdir, theAngularTolerance);
+  }
+
+  //! Computes the angular value, in radians, between this.Direction() and theOther.Direction().
+  //! Returns the angle between 0 and 2*PI radians.
+  Standard_Real Angle (const gp_Ax1& theOther) const { return vdir.Angle (theOther.vdir); }
+
+  //! Reverses the unit vector of this axis and assigns the result to this axis.
+  void Reverse() { vdir.Reverse(); }
+
   //! Reverses the unit vector of this axis and creates a new one.
-    Standard_NODISCARD gp_Ax1 Reversed() const;
-  
+  Standard_NODISCARD gp_Ax1 Reversed() const
+  {
+    gp_Dir D = vdir.Reversed();
+    return gp_Ax1 (loc, D);
+  }
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to the point P which is the
   //! center of the symmetry and assigns the result to this axis.
   Standard_EXPORT void Mirror (const gp_Pnt& P);
-  
+
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to the point P which is the
   //! center of the symmetry and creates a new axis.
   Standard_NODISCARD Standard_EXPORT gp_Ax1 Mirrored (const gp_Pnt& P) const;
-  
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to an axis placement which
   //! is the axis of the symmetry and assigns the result to this axis.
   Standard_EXPORT void Mirror (const gp_Ax1& A1);
-  
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to an axis placement which
   //! is the axis of the symmetry and creates a new axis.
   Standard_NODISCARD Standard_EXPORT gp_Ax1 Mirrored (const gp_Ax1& A1) const;
-  
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to a plane. The axis placement
   //! <A2> locates the plane of the symmetry :
   //! (Location, XDirection, YDirection) and assigns the result to this axis.
   Standard_EXPORT void Mirror (const gp_Ax2& A2);
-  
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to a plane. The axis placement
   //! <A2> locates the plane of the symmetry :
   //! (Location, XDirection, YDirection) and creates a new axis.
   Standard_NODISCARD Standard_EXPORT gp_Ax1 Mirrored (const gp_Ax2& A2) const;
-  
-  //! Rotates this axis at an angle Ang (in radians) about the axis A1
+
+  //! Rotates this axis at an angle theAngRad (in radians) about the axis theA1
   //! and assigns the result to this axis.
-    void Rotate (const gp_Ax1& A1, const Standard_Real Ang);
-  
-  //! Rotates this axis at an angle Ang (in radians) about the axis A1
+  void Rotate (const gp_Ax1& theA1, const Standard_Real theAngRad)
+  {
+    loc .Rotate (theA1, theAngRad);
+    vdir.Rotate (theA1, theAngRad);
+  }
+
+  //! Rotates this axis at an angle theAngRad (in radians) about the axis theA1
   //! and creates a new one.
-    Standard_NODISCARD gp_Ax1 Rotated (const gp_Ax1& A1, const Standard_Real Ang) const;
-  
+  Standard_NODISCARD gp_Ax1 Rotated (const gp_Ax1& theA1, const Standard_Real theAngRad) const
+  {
+    gp_Ax1 A = *this;
+    A.Rotate (theA1, theAngRad);
+    return A;
+  }
 
   //! Applies a scaling transformation to this axis with:
-  //! -   scale factor S, and
-  //! -   center P and assigns the result to this axis.
-    void Scale (const gp_Pnt& P, const Standard_Real S);
-  
+  //! - scale factor theS, and
+  //! - center theP and assigns the result to this axis.
+  void Scale (const gp_Pnt& theP, const Standard_Real theS)
+  {
+    loc.Scale (theP, theS);
+    if (theS < 0.0) { vdir.Reverse(); }
+  }
 
   //! Applies a scaling transformation to this axis with:
-  //! -   scale factor S, and
-  //! -   center P and creates a new axis.
-    Standard_NODISCARD gp_Ax1 Scaled (const gp_Pnt& P, const Standard_Real S) const;
-  
-  //! Applies the transformation T to this axis.
-  //! and assigns the result to this axis.
-    void Transform (const gp_Trsf& T);
-  
-
-  //! Applies the transformation T to this axis and creates a new one.
+  //! - scale factor theS, and
+  //! - center theP and creates a new axis.
+  Standard_NODISCARD gp_Ax1 Scaled (const gp_Pnt& theP, const Standard_Real theS) const
+  {
+    gp_Ax1 A1 = *this;
+    A1.Scale (theP, theS);
+    return A1;
+  }
+
+  //! Applies the transformation theT to this axis and assigns the result to this axis.
+  void Transform (const gp_Trsf& theT)
+  {
+    loc .Transform (theT);
+    vdir.Transform (theT);
+  }
+
+  //! Applies the transformation theT to this axis and creates a new one.
   //!
-  //! Translates an axis plaxement in the direction of the vector
-  //! <V>. The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Ax1 Transformed (const gp_Trsf& T) const;
-  
-
-  //! Translates this axis by the vector V,
-  //! and assigns the result to this axis.
-    void Translate (const gp_Vec& V);
-  
-
-  //! Translates this axis by the vector V,
+  //! Translates an axis plaxement in the direction of the vector <V>.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Ax1 Transformed (const gp_Trsf& theT) const
+  {
+    gp_Ax1 A1 = *this;
+    A1.Transform (theT);
+    return A1;
+  }
+
+  //! Translates this axis by the vector theV, and assigns the result to this axis.
+  void Translate (const gp_Vec& theV) { loc.Translate (theV); }
+
+  //! Translates this axis by the vector theV,
   //! and creates a new one.
-    Standard_NODISCARD gp_Ax1 Translated (const gp_Vec& V) const;
-  
+  Standard_NODISCARD gp_Ax1 Translated (const gp_Vec& theV) const
+  {
+    gp_Ax1 A1 = *this;
+    (A1.loc).Translate (theV); 
+    return A1;
+  }
 
   //! Translates this axis by:
-  //! the vector (P1, P2) defined from point P1 to point P2.
+  //! the vector (theP1, theP2) defined from point theP1 to point theP2.
   //! and assigns the result to this axis.
-    void Translate (const gp_Pnt& P1, const gp_Pnt& P2);
-  
+  void Translate (const gp_Pnt& theP1, const gp_Pnt& theP2) { loc.Translate (theP1, theP2); }
 
   //! Translates this axis by:
-  //! the vector (P1, P2) defined from point P1 to point P2.
+  //! the vector (theP1, theP2) defined from point theP1 to point theP2.
   //! and creates a new one.
-    Standard_NODISCARD gp_Ax1 Translated (const gp_Pnt& P1, const gp_Pnt& P2) const;
-
+  Standard_NODISCARD gp_Ax1 Translated (const gp_Pnt& theP1, const gp_Pnt& theP2) const
+  {
+    gp_Ax1 A1 = *this;
+    (A1.loc).Translate (theP1, theP2);
+    return A1;
+  }
 
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
@@ -211,27 +229,11 @@ public:
   //! Inits the content of me from the stream
   Standard_EXPORT Standard_Boolean InitFromJson (const Standard_SStream& theSStream, Standard_Integer& theStreamPos);
 
-protected:
-
-
-
-
-
 private:
 
-
-
   gp_Pnt loc;
   gp_Dir vdir;
 
-
 };
 
-
-#include <gp_Ax1.lxx>
-
-
-
-
-
 #endif // _gp_Ax1_HeaderFile
diff --git a/src/gp/gp_Ax1.lxx b/src/gp/gp_Ax1.lxx
deleted file mode 100644 (file)
index 0ec76ea..0000000
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// JCV, LPA 07/92
-
-inline gp_Ax1::gp_Ax1() : loc(0.,0.,0.), vdir(0.,0.,1.)
-{ }
-
-inline gp_Ax1::gp_Ax1 (const gp_Pnt& P,
-                      const gp_Dir& V) :  loc(P), vdir(V)
-{ }
-
-inline void gp_Ax1::SetDirection (const gp_Dir& V)
-{ vdir = V; }
-
-inline void gp_Ax1::SetLocation (const gp_Pnt& P)
-{ loc = P; }
-
-inline const gp_Dir& gp_Ax1::Direction () const
-{ return vdir; }
-
-inline const gp_Pnt& gp_Ax1::Location () const
-{ return loc; }
-
-inline Standard_Boolean gp_Ax1::IsNormal
-(const gp_Ax1& Other,
- const Standard_Real AngularTolerance) const
-{ return vdir.IsNormal(Other.vdir, AngularTolerance); }
-
-inline Standard_Boolean gp_Ax1::IsOpposite
-(const gp_Ax1& Other,
- const Standard_Real AngularTolerance) const
-{ return vdir.IsOpposite(Other.vdir, AngularTolerance); }
-
-inline Standard_Boolean gp_Ax1::IsParallel
-(const gp_Ax1& Other,
- const Standard_Real AngularTolerance) const
-{ return vdir.IsParallel(Other.vdir, AngularTolerance); }
-
-inline Standard_Real gp_Ax1::Angle (const gp_Ax1& Other) const
-{ return vdir.Angle (Other.vdir); }
-
-inline void gp_Ax1::Reverse ()
-{ vdir.Reverse(); }
-
-inline gp_Ax1 gp_Ax1::Reversed () const
-{ 
-  gp_Dir D = vdir.Reversed();   
-  return gp_Ax1(loc, D);
-}
-
-inline void gp_Ax1::Rotate (const gp_Ax1& A1, const Standard_Real Ang)
-{
-  loc.Rotate(A1, Ang);
-  vdir.Rotate(A1 , Ang);
-}
-inline gp_Ax1 gp_Ax1::Rotated (const gp_Ax1& A1,
-                       const Standard_Real Ang) const
-{
-  gp_Ax1 A = *this;
-  A.Rotate (A1, Ang);
-  return A;
-}
-
-inline void gp_Ax1::Scale (const gp_Pnt& P,
-                   const Standard_Real S)
-{
-  loc.Scale (P, S);
-  if (S < 0.0)  vdir.Reverse();
-}
-
-inline gp_Ax1 gp_Ax1::Scaled (const gp_Pnt& P,
-                      const Standard_Real S) const
-{
-  gp_Ax1 A1 = *this;
-  A1.Scale (P, S);
-  return A1;
-}
-
-inline void gp_Ax1::Transform (const gp_Trsf& T)
-{ 
-   loc.Transform(T); 
-   vdir.Transform(T);
-}
-
-inline gp_Ax1 gp_Ax1::Transformed (const gp_Trsf& T) const
-{
-  gp_Ax1 A1 = *this;
-  A1.Transform (T);
-  return A1;
-}
-
-inline void gp_Ax1::Translate (const gp_Vec& V)
-{ loc.Translate (V); }
-
-inline gp_Ax1 gp_Ax1::Translated (const gp_Vec& V) const
-{
-  gp_Ax1 A1 = *this;
-  (A1.loc).Translate (V); 
-  return A1;
-}
-
-inline void gp_Ax1::Translate (const gp_Pnt& P1,
-                              const gp_Pnt& P2)
-{
-  loc.Translate (P1, P2);
-}
-
-inline gp_Ax1 gp_Ax1::Translated (const gp_Pnt& P1,
-                          const gp_Pnt& P2) const
-{
-  gp_Ax1 A1 = *this;
-  (A1.loc).Translate (P1, P2);
-  return A1;
-}
-
index 4a1ed08..b1747c5 100644 (file)
 
 #define No_Standard_OutOfRange
 
+#include <gp_Ax2.hxx>
 
 #include <gp.hxx>
 #include <gp_Ax1.hxx>
-#include <gp_Ax2.hxx>
 #include <gp_Dir.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Trsf.hxx>
index 43536b4..d768bda 100644 (file)
 #ifndef _gp_Ax2_HeaderFile
 #define _gp_Ax2_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
 #include <gp_Ax1.hxx>
 #include <gp_Dir.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Boolean.hxx>
+#include <Precision.hxx>
+
 class Standard_ConstructionError;
 class gp_Pnt;
-class gp_Dir;
-class gp_Ax1;
 class gp_Trsf;
 class gp_Vec;
 
-
-
 //! Describes a right-handed coordinate system in 3D space.
 //! A coordinate system is defined by:
 //! -   its origin (also referred to as its "Location point"), and
@@ -66,11 +58,11 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an object corresponding to the reference
   //! coordinate system (OXYZ).
-    gp_Ax2();
-  
+  gp_Ax2() : vydir(0.,1.,0.)
+  // vxdir(1.,0.,0.) use default ctor of gp_Dir, as it creates the same dir(1,0,0)
+  {}
 
   //! Creates an axis placement with an origin P such that:
   //! -   N is the Direction, and
@@ -78,14 +70,20 @@ public:
   //! defined by the vectors (N, Vx): "X
   //! Direction" = (N ^ Vx) ^ N,
   //! Exception: raises ConstructionError if N and Vx are parallel (same or opposite orientation).
-    gp_Ax2(const gp_Pnt& P, const gp_Dir& N, const gp_Dir& Vx);
-  
+  gp_Ax2 (const gp_Pnt& P, const gp_Dir& N, const gp_Dir& Vx)
+  : axis (P, N),
+    vydir (N),
+    vxdir (N)
+  {
+    vxdir.CrossCross(Vx, N);
+    vydir.Cross(vxdir);
+  }
 
   //! Creates -   a coordinate system with an origin P, where V
   //! gives the "main Direction" (here, "X Direction" and "Y
   //! Direction" are defined automatically).
   Standard_EXPORT gp_Ax2(const gp_Pnt& P, const gp_Dir& V);
-  
+
   //! Assigns the origin and "main Direction" of the axis A1 to
   //! this coordinate system, then recomputes its "X Direction" and "Y Direction".
   //! Note: The new "X Direction" is computed as follows:
@@ -95,7 +93,6 @@ public:
   //! Standard_ConstructionError if A1 is parallel to the "X
   //! Direction" of this coordinate system.
   void SetAxis (const gp_Ax1& A1);
-  
 
   //! Changes the "main Direction" of this coordinate system,
   //! then recomputes its "X Direction" and "Y Direction".
@@ -105,11 +102,9 @@ public:
   //! Standard_ConstructionError if V is parallel to the "X
   //! Direction" of this coordinate system.
   void SetDirection (const gp_Dir& V);
-  
 
   //! Changes the "Location" point (origin) of <me>.
-  void SetLocation (const gp_Pnt& P);
-  
+  void SetLocation (const gp_Pnt& theP) { axis.SetLocation (theP); }
 
   //! Changes the "Xdirection" of <me>. The main direction
   //! "Direction" is not modified, the "Ydirection" is modified.
@@ -118,8 +113,11 @@ public:
   //! Exceptions
   //! Standard_ConstructionError if Vx or Vy is parallel to
   //! the "main Direction" of this coordinate system.
-  void SetXDirection (const gp_Dir& Vx);
-  
+  void SetXDirection (const gp_Dir& theVx)
+  {
+    vxdir = axis.Direction().CrossCrossed (theVx, axis.Direction());
+    vydir = axis.Direction().Crossed      (vxdir);
+  }
 
   //! Changes the "Ydirection" of <me>. The main direction is not
   //! modified but the "Xdirection" is changed.
@@ -129,45 +127,41 @@ public:
   //! Exceptions
   //! Standard_ConstructionError if Vx or Vy is parallel to
   //! the "main Direction" of this coordinate system.
-  void SetYDirection (const gp_Dir& Vy);
-  
+  void SetYDirection (const gp_Dir& theVy)
+  {
+    vxdir = theVy.Crossed (axis.Direction());
+    vydir = (axis.Direction()).Crossed (vxdir);
+  }
 
   //! Computes the angular value, in radians, between the main direction of
-  //! <me> and the main direction of <Other>. Returns the angle
+  //! <me> and the main direction of <theOther>. Returns the angle
   //! between 0 and PI in radians.
-  Standard_Real Angle (const gp_Ax2& Other) const;
-  
+  Standard_Real Angle (const gp_Ax2& theOther) const { return axis.Angle (theOther.axis); }
 
   //! Returns the main axis of <me>. It is the "Location" point
   //! and the main "Direction".
-    const gp_Ax1& Axis() const;
-  
+  const gp_Ax1& Axis() const { return axis; }
 
   //! Returns the main direction of <me>.
-    const gp_Dir& Direction() const;
-  
+  const gp_Dir& Direction() const { return axis.Direction(); }
 
   //! Returns the "Location" point (origin) of <me>.
-    const gp_Pnt& Location() const;
-  
+  const gp_Pnt& Location() const { return axis.Location(); }
 
   //! Returns the "XDirection" of <me>.
-    const gp_Dir& XDirection() const;
-  
+  const gp_Dir& XDirection() const { return vxdir; }
 
   //! Returns the "YDirection" of <me>.
-    const gp_Dir& YDirection() const;
-  
+  const gp_Dir& YDirection() const { return vydir; }
+
   Standard_Boolean IsCoplanar (const gp_Ax2& Other, const Standard_Real LinearTolerance, const Standard_Real AngularTolerance) const;
-  
 
   //! Returns True if
   //! . the distance between <me> and the "Location" point of A1
   //! is lower of equal to LinearTolerance and
   //! . the main direction of <me> and the direction of A1 are normal.
   //! Note: the tolerance criterion for angular equality is given by AngularTolerance.
-    Standard_Boolean IsCoplanar (const gp_Ax1& A1, const Standard_Real LinearTolerance, const Standard_Real AngularTolerance) const;
-  
+  Standard_Boolean IsCoplanar (const gp_Ax1& A1, const Standard_Real LinearTolerance, const Standard_Real AngularTolerance) const;
 
   //! Performs a symmetrical transformation of this coordinate
   //! system with respect to:
@@ -185,7 +179,6 @@ public:
   //! This maintains the right-handed property of the
   //! coordinate system.
   Standard_EXPORT void Mirror (const gp_Pnt& P);
-  
 
   //! Performs a symmetrical transformation of this coordinate
   //! system with respect to:
@@ -203,7 +196,6 @@ public:
   //! This maintains the right-handed property of the
   //! coordinate system.
   Standard_NODISCARD Standard_EXPORT gp_Ax2 Mirrored (const gp_Pnt& P) const;
-  
 
   //! Performs a symmetrical transformation of this coordinate
   //! system with respect to:
@@ -221,7 +213,6 @@ public:
   //! This maintains the right-handed property of the
   //! coordinate system.
   Standard_EXPORT void Mirror (const gp_Ax1& A1);
-  
 
   //! Performs a symmetrical transformation of this coordinate
   //! system with respect to:
@@ -239,7 +230,6 @@ public:
   //! This maintains the right-handed property of the
   //! coordinate system.
   Standard_NODISCARD Standard_EXPORT gp_Ax2 Mirrored (const gp_Ax1& A1) const;
-  
 
   //! Performs a symmetrical transformation of this coordinate
   //! system with respect to:
@@ -258,7 +248,6 @@ public:
   //! This maintains the right-handed property of the
   //! coordinate system.
   Standard_EXPORT void Mirror (const gp_Ax2& A2);
-  
 
   //! Performs a symmetrical transformation of this coordinate
   //! system with respect to:
@@ -277,17 +266,37 @@ public:
   //! This maintains the right-handed property of the
   //! coordinate system.
   Standard_NODISCARD Standard_EXPORT gp_Ax2 Mirrored (const gp_Ax2& A2) const;
-  
-    void Rotate (const gp_Ax1& A1, const Standard_Real Ang);
-  
 
-  //! Rotates an axis placement. <A1> is the axis of the
-  //! rotation . Ang is the angular value of the rotation
-  //! in radians.
-    Standard_NODISCARD gp_Ax2 Rotated (const gp_Ax1& A1, const Standard_Real Ang) const;
-  
-    void Scale (const gp_Pnt& P, const Standard_Real S);
-  
+  void Rotate (const gp_Ax1& theA1, const Standard_Real theAng)
+  {
+    gp_Pnt aTemp = axis.Location();
+    aTemp.Rotate (theA1, theAng);
+    axis.SetLocation (aTemp);
+    vxdir.Rotate (theA1, theAng);
+    vydir.Rotate (theA1, theAng);
+    axis.SetDirection (vxdir.Crossed (vydir));
+  }
+
+  //! Rotates an axis placement. <theA1> is the axis of the rotation.
+  //! theAng is the angular value of the rotation in radians.
+  Standard_NODISCARD gp_Ax2 Rotated (const gp_Ax1& theA1, const Standard_Real theAng) const
+  {
+    gp_Ax2 aTemp = *this;
+    aTemp.Rotate (theA1, theAng);
+    return aTemp;
+  } 
+
+  void Scale (const gp_Pnt& theP, const Standard_Real theS)
+  {
+    gp_Pnt aTemp = axis.Location();
+    aTemp.Scale (theP, theS);
+    axis.SetLocation (aTemp);
+    if (theS < 0.0)
+    {
+      vxdir.Reverse();
+      vydir.Reverse();
+    }
+  }
 
   //! Applies a scaling transformation on the axis placement.
   //! The "Location" point of the axisplacement is modified.
@@ -296,32 +305,54 @@ public:
   //! . the main direction of the axis placement is not changed.
   //! . The "XDirection" and the "YDirection" are reversed.
   //! So the axis placement stay right handed.
-    Standard_NODISCARD gp_Ax2 Scaled (const gp_Pnt& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf& T);
-  
+  Standard_NODISCARD gp_Ax2 Scaled (const gp_Pnt& theP, const Standard_Real theS) const
+  {
+    gp_Ax2 aTemp = *this;
+    aTemp.Scale (theP, theS);
+    return aTemp;
+  }
+
+  void Transform (const gp_Trsf& theT)
+  {
+    gp_Pnt aTemp = axis.Location();
+    aTemp.Transform (theT);
+    axis.SetLocation (aTemp);
+    vxdir.Transform (theT);
+    vydir.Transform (theT);
+    axis.SetDirection (vxdir.Crossed (vydir));
+  }
 
   //! Transforms an axis placement with a Trsf.
-  //! The "Location" point, the "XDirection" and the
-  //! "YDirection" are transformed with T.  The resulting
-  //! main "Direction" of <me> is the cross product between
+  //! The "Location" point, the "XDirection" and the "YDirection" are transformed with theT.
+  //! The resulting main "Direction" of <me> is the cross product between
   //! the "XDirection" and the "YDirection" after transformation.
-    Standard_NODISCARD gp_Ax2 Transformed (const gp_Trsf& T) const;
-  
-    void Translate (const gp_Vec& V);
-  
-
-  //! Translates an axis plaxement in the direction of the vector
-  //! <V>. The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Ax2 Translated (const gp_Vec& V) const;
-  
-    void Translate (const gp_Pnt& P1, const gp_Pnt& P2);
-  
-
-  //! Translates an axis placement from the point <P1> to the
-  //! point <P2>.
-    Standard_NODISCARD gp_Ax2 Translated (const gp_Pnt& P1, const gp_Pnt& P2) const;
-
+  Standard_NODISCARD gp_Ax2 Transformed (const gp_Trsf& theT) const
+  {
+    gp_Ax2 aTemp = *this;
+    aTemp.Transform (theT);
+    return aTemp;
+  }
+  
+  void Translate (const gp_Vec& theV) { axis.Translate (theV); }
+
+  //! Translates an axis plaxement in the direction of the vector <theV>.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Ax2 Translated (const gp_Vec& theV) const
+  {
+    gp_Ax2 aTemp = *this;
+    aTemp.Translate (theV);
+    return aTemp;
+  }
+
+  void Translate (const gp_Pnt& theP1, const gp_Pnt& theP2) { axis.Translate (theP1, theP2); }
+
+  //! Translates an axis placement from the point <theP1> to the point <theP2>.
+  Standard_NODISCARD gp_Ax2 Translated (const gp_Pnt& theP1, const gp_Pnt& theP2) const
+  {
+    gp_Ax2 aTemp = *this;
+    aTemp.Translate (theP1, theP2);
+    return aTemp;
+  }
 
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
@@ -329,30 +360,114 @@ public:
   //! Inits the content of me from the stream
   Standard_EXPORT Standard_Boolean InitFromJson (const Standard_SStream& theSStream, Standard_Integer& theStreamPos);
 
-
-
-protected:
-
-
-
-
-
 private:
 
-
-
   gp_Ax1 axis;
   gp_Dir vydir;
   gp_Dir vxdir;
 
-
 };
 
-
-#include <gp_Ax2.lxx>
-
-
-
-
+// =======================================================================
+// function : SetAxis
+// purpose  :
+// =======================================================================
+inline void gp_Ax2::SetAxis (const gp_Ax1& theA1)
+{
+  Standard_Real a =  theA1.Direction() * vxdir;
+  if (Abs(Abs(a) - 1.) <= Precision::Angular())
+  {
+    if (a > 0.)
+    {
+      vxdir = vydir;
+      vydir = axis.Direction();
+      axis = theA1;
+    }
+    else
+    {
+      vxdir = axis.Direction();
+      axis = theA1;
+    }
+  }
+  else
+  {
+    axis = theA1;
+    vxdir = axis.Direction().CrossCrossed (vxdir, axis.Direction());
+    vydir = axis.Direction().Crossed      (vxdir);
+  }
+}
+
+// =======================================================================
+// function : SetDirection
+// purpose  :
+// =======================================================================
+inline void gp_Ax2::SetDirection (const gp_Dir& theV)
+{ 
+  Standard_Real a =  theV * vxdir;
+  if (Abs(Abs(a) - 1.) <= Precision::Angular())
+  {
+    if(a > 0.)
+    {
+      vxdir = vydir;
+      vydir = axis.Direction();
+      axis.SetDirection (theV);
+    }
+    else
+    {
+      vxdir = axis.Direction();
+      axis.SetDirection (theV);
+    }
+  }
+  else
+  {
+    axis.SetDirection (theV);
+    vxdir = theV.CrossCrossed (vxdir, theV);
+    vydir = theV.Crossed (vxdir);
+  }
+}
+
+// =======================================================================
+// function : IsCoplanar
+// purpose  :
+// =======================================================================
+inline Standard_Boolean gp_Ax2::IsCoplanar (const gp_Ax2& theOther,
+                                            const Standard_Real theLinearTolerance,
+                                            const Standard_Real theAngularTolerance) const
+{
+  const gp_Dir& DD =          axis.Direction();
+  const gp_Pnt& PP =          axis.Location();
+  const gp_Pnt& OP = theOther.axis.Location();
+  Standard_Real D1 = (DD.X() * (OP.X() - PP.X())
+                    + DD.Y() * (OP.Y() - PP.Y())
+                    + DD.Z() * (OP.Z() - PP.Z()));
+  if (D1 < 0)
+  {
+    D1 = -D1;
+  }
+  return D1 <= theLinearTolerance
+      && axis.IsParallel (theOther.axis, theAngularTolerance);
+}
+
+// =======================================================================
+// function : IsCoplanar
+// purpose  :
+// =======================================================================
+inline Standard_Boolean gp_Ax2::IsCoplanar (const gp_Ax1& theA,
+                                            const Standard_Real theLinearTolerance,
+                                            const Standard_Real theAngularTolerance) const
+{
+  const gp_Dir& DD = axis.Direction();
+  const gp_Pnt& PP = axis.Location();
+  const gp_Pnt& AP = theA.Location();
+  Standard_Real D1 = (DD.X() * (AP.X() - PP.X()) + 
+                      DD.Y() * (AP.Y() - PP.Y()) + 
+                      DD.Z() * (AP.Z() - PP.Z()));
+  if (D1 < 0)
+  {
+    D1 = -D1;
+  }
+  return D1 <= theLinearTolerance
+      && axis.IsNormal (theA, theAngularTolerance);
+}
 
 #endif // _gp_Ax2_HeaderFile
diff --git a/src/gp/gp_Ax2.lxx b/src/gp/gp_Ax2.lxx
deleted file mode 100644 (file)
index 3e94b37..0000000
+++ /dev/null
@@ -1,212 +0,0 @@
-// Copyright (c) 1996-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Precision.hxx>
-
-inline gp_Ax2::gp_Ax2()
-  :
-  vydir(0.,1.,0.)
-  // vxdir(1.,0.,0.) use default ctor of gp_Dir, as it creates the same dir(1,0,0)
-{ }
-
-inline gp_Ax2::gp_Ax2(const gp_Pnt& P,
-                     const gp_Dir& N,
-                     const gp_Dir& Vx) : axis(P, N), vydir(N), vxdir(N)
-{
-  vxdir.CrossCross(Vx, N);
-  vydir.Cross(vxdir);
-}
-
-inline void gp_Ax2::SetAxis (const gp_Ax1&  A1)
-{
-  Standard_Real a =  A1.Direction() * vxdir;
-  if(Abs(Abs(a) - 1.) <= Precision::Angular()) {
-    if(a > 0.) {
-      vxdir = vydir;
-      vydir = axis.Direction();
-      axis = A1;
-    }
-    else {
-      vxdir = axis.Direction();
-      axis = A1;
-    }
-  }
-  else {
-    axis = A1;
-    vxdir = axis.Direction().CrossCrossed (vxdir, axis.Direction());
-    vydir = axis.Direction().Crossed      (vxdir);
-  }
-}
-
-inline void gp_Ax2::SetDirection (const gp_Dir&  V)
-{ 
-  Standard_Real a =  V * vxdir;
-  if(Abs(Abs(a) - 1.) <= Precision::Angular()) {
-    if(a > 0.) {
-      vxdir = vydir;
-      vydir = axis.Direction();
-      axis.SetDirection (V);
-    }
-    else {
-      vxdir = axis.Direction();
-      axis.SetDirection (V);
-    }
-  }
-  else {
-    axis.SetDirection (V);
-    vxdir = V.CrossCrossed (vxdir, V);
-    vydir = V.Crossed (vxdir);
-  }
-}
-
-inline void gp_Ax2::SetLocation (const gp_Pnt& P)
-{ axis.SetLocation(P); }
-
-inline void gp_Ax2::SetXDirection (const gp_Dir&  Vx)
-{
-  vxdir = axis.Direction().CrossCrossed (Vx, axis.Direction());
-  vydir = axis.Direction().Crossed      (vxdir);
-}
-
-inline void gp_Ax2::SetYDirection (const gp_Dir& Vy)
-{
-  vxdir = Vy.Crossed (axis.Direction());
-  vydir = (axis.Direction()).Crossed (vxdir);
-}
-
-inline Standard_Real gp_Ax2::Angle (const gp_Ax2& Other) const
-{ return axis.Angle (Other.axis); }
-
-inline const gp_Ax1& gp_Ax2::Axis () const
-{ return axis; }
-
-inline const gp_Dir& gp_Ax2::Direction () const
-{ return axis.Direction(); }
-
-inline const gp_Pnt& gp_Ax2::Location () const
-{ return axis.Location(); }
-
-inline const gp_Dir& gp_Ax2::XDirection () const
-{ return vxdir; }
-
-inline const gp_Dir& gp_Ax2::YDirection () const
-{ return vydir; }
-
-inline Standard_Boolean gp_Ax2::IsCoplanar 
-(const gp_Ax2& Other,
- const Standard_Real LinearTolerance,
- const Standard_Real AngularTolerance) const
-{
-  const gp_Dir& DD =       axis.Direction();
-  const gp_Pnt& PP =       axis.Location ();
-  const gp_Pnt& OP = Other.axis.Location ();
-  Standard_Real D1 = (DD.X() * (OP.X() - PP.X()) + 
-                     DD.Y() * (OP.Y() - PP.Y()) + 
-                     DD.Z() * (OP.Z() - PP.Z()));
-  if (D1 < 0 ) D1 = - D1;
-  return (D1 <= LinearTolerance &&
-         axis.IsParallel (Other.axis, AngularTolerance));
-}
-
-inline Standard_Boolean gp_Ax2::IsCoplanar
-(const gp_Ax1& A,
- const Standard_Real LinearTolerance,
- const Standard_Real AngularTolerance) const
-{
-  const gp_Dir& DD = axis.Direction();
-  const gp_Pnt& PP = axis.Location ();
-  const gp_Pnt& AP = A   .Location ();
-  Standard_Real D1 = (DD.X() * (AP.X() - PP.X()) + 
-                     DD.Y() * (AP.Y() - PP.Y()) + 
-                     DD.Z() * (AP.Z() - PP.Z()));
-  if (D1 < 0) D1 = - D1;
-  return (D1 <= LinearTolerance &&
-         axis.IsNormal (A, AngularTolerance));
-}
-
-inline void gp_Ax2::Rotate(const gp_Ax1& A1, const Standard_Real Ang)
-{
-  gp_Pnt Temp = axis.Location();
-  Temp.Rotate  (A1, Ang);
-  axis.SetLocation (Temp);
-  vxdir.Rotate (A1, Ang);
-  vydir.Rotate (A1, Ang);
-  axis.SetDirection (vxdir.Crossed (vydir));
-}
-
-inline gp_Ax2 gp_Ax2::Rotated(const gp_Ax1& A1,
-                             const Standard_Real Ang) const
-{
-  gp_Ax2 Temp = *this;
-  Temp.Rotate (A1, Ang);
-  return Temp;
-} 
-
-inline void gp_Ax2::Scale (const gp_Pnt& P, const Standard_Real S)
-{
-  gp_Pnt Temp = axis.Location();
-  Temp.Scale (P, S);
-  axis.SetLocation (Temp);
-  if (S < 0.0) {
-    vxdir.Reverse ();
-    vydir.Reverse ();
-  }
-}
-
-inline gp_Ax2 gp_Ax2::Scaled(const gp_Pnt& P,
-                            const Standard_Real S) const 
-{
-  gp_Ax2 Temp = *this;
-  Temp.Scale (P, S);
-  return Temp;
-}
-
-inline void gp_Ax2::Transform (const gp_Trsf& T)
-{
-  gp_Pnt Temp = axis.Location();
-  Temp.Transform (T);
-  axis.SetLocation (Temp);
-  vxdir.Transform (T);
-  vydir.Transform (T);
-  axis.SetDirection (vxdir.Crossed (vydir));
-}
-
-inline gp_Ax2 gp_Ax2::Transformed(const gp_Trsf& T) const
-{
-  gp_Ax2 Temp = *this;
-  Temp.Transform (T);
-  return Temp;
-}
-
-inline void gp_Ax2::Translate (const gp_Vec& V)
-{ axis.Translate (V); }
-
-inline gp_Ax2 gp_Ax2::Translated(const gp_Vec& V) const
-{
-  gp_Ax2 Temp = *this;
-  Temp.Translate (V);
-  return Temp;
-}
-
-inline void gp_Ax2::Translate (const gp_Pnt& P1, const gp_Pnt& P2)
-{ axis.Translate (P1, P2); }
-
-inline gp_Ax2 gp_Ax2::Translated (const gp_Pnt& P1,
-                                 const gp_Pnt& P2)  const
-{
-  gp_Ax2 Temp = *this;
-  Temp.Translate (P1, P2);
-  return Temp;
-}
-
index fc8b27f..68ce564 100644 (file)
@@ -17,8 +17,9 @@
 // LPA, JCV  07/92 passage sur C1.
 // JCV 07/92 Introduction de la method Dump 
 
-#include <gp_Ax2d.hxx>
 #include <gp_Ax22d.hxx>
+
+#include <gp_Ax2d.hxx>
 #include <gp_Dir2d.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_Trsf2d.hxx>
index 5fdc707..53a3933 100644 (file)
 #ifndef _gp_Ax22d_HeaderFile
 #define _gp_Ax22d_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <gp_Pnt2d.hxx>
-#include <gp_Dir2d.hxx>
-#include <Standard_Boolean.hxx>
 #include <gp_Ax2d.hxx>
-#include <Standard_Real.hxx>
-class Standard_ConstructionError;
-class gp_Pnt2d;
-class gp_Dir2d;
-class gp_Ax2d;
-class gp_Trsf2d;
-class gp_Vec2d;
-
-
+#include <gp_Dir2d.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <Standard_ConstructionError.hxx>
 
 //! Describes a coordinate system in a plane (2D space).
 //! A coordinate system is defined by:
@@ -56,106 +45,138 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an object representing the reference
   //! coordinate system (OXY).
-    gp_Ax22d();
-  
-
-  //! Creates a coordinate system with origin P and where:
-  //! -   Vx is the "X Direction", and
-  //! -   the "Y Direction" is orthogonal to Vx and
-  //! oriented so that the cross products Vx^"Y
-  //! Direction" and Vx^Vy have the same sign.
-  //! Raises ConstructionError if Vx and Vy are parallel (same or opposite orientation).
-    gp_Ax22d(const gp_Pnt2d& P, const gp_Dir2d& Vx, const gp_Dir2d& Vy);
-  
-
-  //! Creates -   a coordinate system with origin P and "X Direction"
-  //! V, which is:
-  //! -   right-handed if Sense is true (default value), or
-  //! -   left-handed if Sense is false
-    gp_Ax22d(const gp_Pnt2d& P, const gp_Dir2d& V, const Standard_Boolean Sense = Standard_True);
-  
+  gp_Ax22d() : vydir (0., 1.)
+  // vxdir(1.,0.) use default ctor of gp_Dir2d, as it creates the same dir(1, 0)
+  {}
+
+  //! Creates a coordinate system with origin theP and where:
+  //! -   theVx is the "X Direction", and
+  //! -   the "Y Direction" is orthogonal to theVx and
+  //! oriented so that the cross products theVx^"Y
+  //! Direction" and theVx^theVy have the same sign.
+  //! Raises ConstructionError if theVx and theVy are parallel (same or opposite orientation).
+  gp_Ax22d (const gp_Pnt2d& theP, const gp_Dir2d& theVx, const gp_Dir2d& theVy)
+  : point (theP),
+    vydir (theVy),
+    vxdir (theVx)
+  {
+    Standard_Real aValue = theVx.Crossed (theVy);
+    if (aValue >= 0.0)
+    {
+      vydir.SetCoord (-vxdir.Y(), vxdir.X());
+    }
+    else
+    {
+      vydir.SetCoord (vxdir.Y(), -vxdir.X());
+    }
+  }
+
+  //! Creates -   a coordinate system with origin theP and "X Direction"
+  //! theV, which is:
+  //! -   right-handed if theIsSense is true (default value), or
+  //! -   left-handed if theIsSense is false
+  gp_Ax22d (const gp_Pnt2d& theP, const gp_Dir2d& theV, const Standard_Boolean theIsSense = Standard_True)
+  : point (theP),
+    vxdir (theV)
+  {
+    if (theIsSense)
+    {
+      vydir.SetCoord (-theV.Y(), theV.X());
+    }
+    else
+    {
+      vydir.SetCoord (theV.Y(), -theV.X());
+    }
+  }
 
   //! Creates -   a coordinate system where its origin is the origin of
-  //! A and its "X Direction" is the unit vector of A, which   is:
-  //! -   right-handed if Sense is true (default value), or
-  //! -   left-handed if Sense is false.
-    gp_Ax22d(const gp_Ax2d& A, const Standard_Boolean Sense = Standard_True);
-  
+  //! theA and its "X Direction" is the unit vector of theA, which   is:
+  //! -   right-handed if theIsSense is true (default value), or
+  //! -   left-handed if theIsSense is false.
+  gp_Ax22d (const gp_Ax2d& theA, const Standard_Boolean theIsSense = Standard_True)
+  : point (theA.Location()),
+    vxdir (theA.Direction())
+  {
+    if (theIsSense)
+    {
+      vydir.SetCoord (-vxdir.Y(), vxdir.X());
+    }
+    else
+    {
+      vydir.SetCoord (vxdir.Y(), -vxdir.X());
+    }
+  }
 
   //! Assigns the origin and the two unit vectors of the
-  //! coordinate system A1 to this coordinate system.
-    void SetAxis (const gp_Ax22d& A1);
-  
+  //! coordinate system theA1 to this coordinate system.
+  void SetAxis (const gp_Ax22d& theA1)
+  {
+    point = theA1.Location();
+    vxdir = theA1.XDirection();
+    vydir = theA1.YDirection();
+  }
 
   //! Changes the XAxis and YAxis ("Location" point and "Direction")
   //! of <me>.
   //! The "YDirection" is recomputed in the same sense as before.
-    void SetXAxis (const gp_Ax2d& A1);
-  
+  void SetXAxis (const gp_Ax2d& theA1);
+
   //! Changes the XAxis and YAxis ("Location" point and "Direction") of <me>.
   //! The "XDirection" is recomputed in the same sense as before.
-    void SetYAxis (const gp_Ax2d& A1);
-  
+  void SetYAxis (const gp_Ax2d& theA1);
 
   //! Changes the "Location" point (origin) of <me>.
-    void SetLocation (const gp_Pnt2d& P);
-  
+  void SetLocation (const gp_Pnt2d& theP) { point = theP; }
 
-  //! Assigns Vx to the "X Direction"  of
+  //! Assigns theVx to the "X Direction"  of
   //! this coordinate system. The other unit vector of this
-  //! coordinate system is recomputed, normal to Vx ,
+  //! coordinate system is recomputed, normal to theVx ,
   //! without modifying the orientation (right-handed or
   //! left-handed) of this coordinate system.
-    void SetXDirection (const gp_Dir2d& Vx);
-  
-  //! Assignsr Vy to the  "Y Direction" of
+  void SetXDirection (const gp_Dir2d& theVx);
+
+  //! Assignsr theVy to the  "Y Direction" of
   //! this coordinate system. The other unit vector of this
-  //! coordinate system is recomputed, normal to Vy,
+  //! coordinate system is recomputed, normal to theVy,
   //! without modifying the orientation (right-handed or
   //! left-handed) of this coordinate system.
-    void SetYDirection (const gp_Dir2d& Vy);
-  
+  void SetYDirection (const gp_Dir2d& theVy);
+
   //! Returns an axis, for which
   //! -   the origin is that of this coordinate system, and
   //! -   the unit vector is either the "X Direction"  of this coordinate system.
   //! Note: the result is the "X Axis" of this coordinate system.
-    gp_Ax2d XAxis() const;
-  
+  gp_Ax2d XAxis() const { return gp_Ax2d (point, vxdir); }
+
   //! Returns an axis, for which
   //! -   the origin is that of this coordinate system, and
   //! - the unit vector is either the  "Y Direction" of this coordinate system.
   //! Note: the result is the "Y Axis" of this coordinate system.
-    gp_Ax2d YAxis() const;
-  
+  gp_Ax2d YAxis() const { return gp_Ax2d (point, vydir); }
 
   //! Returns the "Location" point (origin) of <me>.
-    const gp_Pnt2d& Location() const;
-  
+  const gp_Pnt2d& Location() const { return point; }
 
   //! Returns the "XDirection" of <me>.
-    const gp_Dir2d& XDirection() const;
-  
+  const gp_Dir2d& XDirection() const { return vxdir; }
 
   //! Returns the "YDirection" of <me>.
-    const gp_Dir2d& YDirection() const;
-  
-  Standard_EXPORT void Mirror (const gp_Pnt2d& P);
-  
+  const gp_Dir2d& YDirection() const { return vydir; }
+
+  Standard_EXPORT void Mirror (const gp_Pnt2d& theP);
 
   //! Performs the symmetrical transformation of an axis
-  //! placement with respect to the point P which is the
+  //! placement with respect to the point theP which is the
   //! center of the symmetry.
   //! Warnings :
   //! The main direction of the axis placement is not changed.
   //! The "XDirection" and the "YDirection" are reversed.
   //! So the axis placement stay right handed.
-  Standard_NODISCARD Standard_EXPORT gp_Ax22d Mirrored (const gp_Pnt2d& P) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2d& A);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Ax22d Mirrored (const gp_Pnt2d& theP) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2d& theA);
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to an axis placement which
@@ -164,80 +185,197 @@ public:
   //! point, on the "XDirection" and "YDirection".
   //! The resulting main "Direction" is the cross product between
   //! the "XDirection" and the "YDirection" after transformation.
-  Standard_NODISCARD Standard_EXPORT gp_Ax22d Mirrored (const gp_Ax2d& A) const;
-  
-    void Rotate (const gp_Pnt2d& P, const Standard_Real Ang);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Ax22d Mirrored (const gp_Ax2d& theA) const;
 
-  //! Rotates an axis placement. <A1> is the axis of the
-  //! rotation . Ang is the angular value of the rotation
+  void Rotate (const gp_Pnt2d& theP, const Standard_Real theAng);
+
+  //! Rotates an axis placement. <theA1> is the axis of the
+  //! rotation . theAng is the angular value of the rotation
   //! in radians.
-    Standard_NODISCARD gp_Ax22d Rotated (const gp_Pnt2d& P, const Standard_Real Ang) const;
-  
-    void Scale (const gp_Pnt2d& P, const Standard_Real S);
-  
+  Standard_NODISCARD gp_Ax22d Rotated (const gp_Pnt2d& theP, const Standard_Real theAng) const
+  {
+    gp_Ax22d aTemp = *this;
+    aTemp.Rotate (theP, theAng);
+    return aTemp;
+  }
+
+  void Scale (const gp_Pnt2d& theP, const Standard_Real theS);
 
   //! Applies a scaling transformation on the axis placement.
   //! The "Location" point of the axisplacement is modified.
   //! Warnings :
-  //! If the scale <S> is negative :
+  //! If the scale <theS> is negative :
   //! . the main direction of the axis placement is not changed.
   //! . The "XDirection" and the "YDirection" are reversed.
   //! So the axis placement stay right handed.
-    Standard_NODISCARD gp_Ax22d Scaled (const gp_Pnt2d& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf2d& T);
-  
+  Standard_NODISCARD gp_Ax22d Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const
+  {
+    gp_Ax22d aTemp = *this;
+    aTemp.Scale (theP, theS);
+    return aTemp;
+  }
+
+  void Transform (const gp_Trsf2d& theT);
 
   //! Transforms an axis placement with a Trsf.
   //! The "Location" point, the "XDirection" and the
-  //! "YDirection" are transformed with T.  The resulting
+  //! "YDirection" are transformed with theT.  The resulting
   //! main "Direction" of <me> is the cross product between
   //! the "XDirection" and the "YDirection" after transformation.
-    Standard_NODISCARD gp_Ax22d Transformed (const gp_Trsf2d& T) const;
-  
-    void Translate (const gp_Vec2d& V);
-  
+  Standard_NODISCARD gp_Ax22d Transformed (const gp_Trsf2d& theT) const
+  {
+    gp_Ax22d aTemp = *this;
+    aTemp.Transform (theT);
+    return aTemp;
+  }
 
-  //! Translates an axis plaxement in the direction of the vector
-  //! <V>. The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Ax22d Translated (const gp_Vec2d& V) const;
-  
-    void Translate (const gp_Pnt2d& P1, const gp_Pnt2d& P2);
-  
+  void Translate (const gp_Vec2d& theV) { point.Translate (theV); }
 
-  //! Translates an axis placement from the point <P1> to the
-  //! point <P2>.
-    Standard_NODISCARD gp_Ax22d Translated (const gp_Pnt2d& P1, const gp_Pnt2d& P2) const;
+  //! Translates an axis plaxement in the direction of the vector
+  //! <theV>. The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Ax22d Translated (const gp_Vec2d& theV) const
+  {
+    gp_Ax22d aTemp = *this;
+    aTemp.Translate (theV);
+    return aTemp;
+  }
+
+  void Translate (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) { point.Translate (theP1, theP2); }
+
+  //! Translates an axis placement from the point <theP1> to the
+  //! point <theP2>.
+  Standard_NODISCARD gp_Ax22d Translated (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) const
+  {
+    gp_Ax22d aTemp = *this;
+    aTemp.Translate (theP1, theP2);
+    return aTemp;
+  }
 
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
 
-
-
-
-protected:
-
-
-
-
-
 private:
 
-
-
   gp_Pnt2d point;
   gp_Dir2d vydir;
   gp_Dir2d vxdir;
 
-
 };
 
-
-#include <gp_Ax22d.lxx>
-
-
-
-
+// =======================================================================
+// function : SetDirection
+// purpose  :
+// =======================================================================
+inline void gp_Ax22d::SetXAxis (const gp_Ax2d& theA1)
+{
+  Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
+  point = theA1.Location ();
+  vxdir = theA1.Direction();
+  if (isSign)
+  {
+    vydir.SetCoord (-vxdir.Y(), vxdir.X());
+  }
+  else
+  {
+    vydir.SetCoord (vxdir.Y(), -vxdir.X());
+  }
+}
+
+// =======================================================================
+// function : SetDirection
+// purpose  :
+// =======================================================================
+inline void gp_Ax22d::SetYAxis (const gp_Ax2d& theA1)
+{
+  Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
+  point = theA1.Location ();
+  vydir = theA1.Direction();
+  if (isSign)
+  {
+    vxdir.SetCoord (vydir.Y(), -vydir.X());
+  }
+  else
+  {
+    vxdir.SetCoord (-vydir.Y(), vydir.X());
+  }
+}
+
+// =======================================================================
+// function : SetXDirection
+// purpose  :
+// =======================================================================
+inline void gp_Ax22d::SetXDirection (const gp_Dir2d& theVx)
+{ 
+  Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
+  vxdir = theVx;
+  if (isSign)
+  {
+    vydir.SetCoord (-theVx.Y(), theVx.X());
+  }
+  else
+  {
+    vydir.SetCoord (theVx.Y(), -theVx.X());
+  }
+}
+
+// =======================================================================
+// function : SetYDirection
+// purpose  :
+// =======================================================================
+inline void gp_Ax22d::SetYDirection (const gp_Dir2d& theVy)
+{
+  Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
+  vydir = theVy;
+  if (isSign)
+  {
+    vxdir.SetCoord (theVy.Y(), -theVy.X());
+  }
+  else
+  {
+    vxdir.SetCoord (-theVy.Y(), theVy.X());
+  }
+}
+
+// =======================================================================
+// function : Rotate
+// purpose  :
+// =======================================================================
+inline void gp_Ax22d::Rotate (const gp_Pnt2d& theP, const Standard_Real theAng)
+{
+  gp_Pnt2d aTemp = point;
+  aTemp.Rotate (theP, theAng);
+  point = aTemp;
+  vxdir.Rotate (theAng);
+  vydir.Rotate (theAng);
+}
+
+// =======================================================================
+// function : Scale
+// purpose  :
+// =======================================================================
+inline void gp_Ax22d::Scale (const gp_Pnt2d& theP, const Standard_Real theS)
+{
+  gp_Pnt2d aTemp = point;
+  aTemp.Scale (theP, theS);
+  point = aTemp;
+  if (theS < 0.0)
+  {
+    vxdir.Reverse();
+    vydir.Reverse();
+  }
+}
+
+// =======================================================================
+// function : Transform
+// purpose  :
+// =======================================================================
+inline void gp_Ax22d::Transform (const gp_Trsf2d& theT)
+{
+  gp_Pnt2d aTemp = point;
+  aTemp.Transform (theT);
+  point = aTemp;
+  vxdir.Transform (theT);
+  vydir.Transform (theT);
+}
 
 #endif // _gp_Ax22d_HeaderFile
diff --git a/src/gp/gp_Ax22d.lxx b/src/gp/gp_Ax22d.lxx
deleted file mode 100644 (file)
index 40d1597..0000000
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright (c) 1996-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-inline gp_Ax22d::gp_Ax22d()
-  :
-  vydir(0.,1.)
-  // vxdir(1.,0.) use default ctor of gp_Dir2d, as it creates the same dir(1, 0)
-{}
-
-inline gp_Ax22d::gp_Ax22d(const gp_Pnt2d& P , 
-                         const gp_Dir2d& Vx, 
-                         const gp_Dir2d& Vy) : 
-                         point(P), 
-                         vydir(Vy), 
-                         vxdir(Vx)
-{
-  Standard_Real value = Vx.Crossed(Vy);
-  if (value >= 0.0) vydir.SetCoord(-vxdir.Y(), vxdir.X());
-  else              vydir.SetCoord( vxdir.Y(),-vxdir.X());
-}
-
-inline gp_Ax22d::gp_Ax22d(const gp_Pnt2d&        P    , 
-                         const gp_Dir2d&        Vx   , 
-                         const Standard_Boolean Sense) : 
-                         point(P), 
-                         vxdir(Vx)
-{
-  if (Sense) vydir.SetCoord(-Vx.Y(), Vx.X());
-  else       vydir.SetCoord( Vx.Y(),-Vx.X());
-}
-
-inline gp_Ax22d::gp_Ax22d(const gp_Ax2d&         A   , 
-                         const Standard_Boolean Sense) : 
-                         point(A.Location()), 
-                         vxdir(A.Direction())
-{
-  if (Sense) vydir.SetCoord(-vxdir.Y(), vxdir.X());
-  else       vydir.SetCoord( vxdir.Y(),-vxdir.X());
-}
-
-inline void gp_Ax22d::SetAxis(const gp_Ax22d&  A1)
-{
-  point = A1.Location();
-  vxdir = A1.XDirection();
-  vydir = A1.YDirection();
-}
-
-inline void gp_Ax22d::SetXAxis (const gp_Ax2d&  A1)
-{
-  Standard_Boolean sign = (vxdir.Crossed(vydir)) >= 0.0;
-  point = A1.Location ();
-  vxdir = A1.Direction();
-  if (sign) vydir.SetCoord(-vxdir.Y(), vxdir.X());
-  else      vydir.SetCoord( vxdir.Y(),-vxdir.X());
-}
-
-inline void gp_Ax22d::SetYAxis (const gp_Ax2d&  A1)
-{
-  Standard_Boolean sign = (vxdir.Crossed(vydir)) >= 0.0;
-  point = A1.Location ();
-  vydir = A1.Direction();
-  if (sign) vxdir.SetCoord( vydir.Y(),-vydir.X());
-  else      vxdir.SetCoord(-vydir.Y(), vydir.X());
-}
-
-inline void gp_Ax22d::SetLocation (const gp_Pnt2d& P)
-{ point = P; }
-
-inline void gp_Ax22d::SetXDirection (const gp_Dir2d&  Vx)
-{ 
-  Standard_Boolean sign = (vxdir.Crossed(vydir)) >= 0.0;
-  vxdir = Vx;
-  if (sign) vydir.SetCoord(-Vx.Y(), Vx.X());
-  else      vydir.SetCoord( Vx.Y(),-Vx.X());
-}
-
-inline void gp_Ax22d::SetYDirection (const gp_Dir2d& Vy)
-{
-  Standard_Boolean sign = (vxdir.Crossed(vydir)) >= 0.0;
-  vydir = Vy;
-  if (sign) vxdir.SetCoord( Vy.Y(),-Vy.X());
-  else      vxdir.SetCoord(-Vy.Y(), Vy.X());
-}
-
-inline gp_Ax2d gp_Ax22d::XAxis () const
-{  return gp_Ax2d(point, vxdir); }
-
-inline gp_Ax2d gp_Ax22d::YAxis () const
-{  return gp_Ax2d(point, vydir); }
-
-inline const gp_Pnt2d& gp_Ax22d::Location () const
-{ return point; }
-
-inline const gp_Dir2d& gp_Ax22d::XDirection () const
-{ return vxdir; }
-
-inline const gp_Dir2d& gp_Ax22d::YDirection () const
-{ return vydir; }
-
-inline void gp_Ax22d::Rotate (const gp_Pnt2d& P,
-                             const Standard_Real Ang)
-{
-  gp_Pnt2d Temp = point;
-  Temp.Rotate (P,Ang);
-  point = Temp;
-  vxdir.Rotate (Ang);
-  vydir.Rotate (Ang);
-}
-
-inline gp_Ax22d gp_Ax22d::Rotated(const gp_Pnt2d& P,
-                                 const Standard_Real Ang) const
-{
-  gp_Ax22d Temp = *this;
-  Temp.Rotate (P,Ang);
-  return Temp;
-}
-
-inline void gp_Ax22d::Scale (const gp_Pnt2d& P, 
-                            const Standard_Real S)
-{
-  gp_Pnt2d Temp = point;
-  Temp.Scale (P, S);
-  point = Temp;
-  if (S < 0.0) {
-    vxdir.Reverse ();
-    vydir.Reverse ();
-  }
-}
-
-inline gp_Ax22d gp_Ax22d::Scaled(const gp_Pnt2d& P, 
-                                const Standard_Real S) const 
-{
-  gp_Ax22d Temp = *this;
-  Temp.Scale (P, S);
-  return Temp;
-}
-
-inline void gp_Ax22d::Transform (const gp_Trsf2d& T)
-{
-  gp_Pnt2d Temp = point;
-  Temp.Transform (T);
-  point = Temp;
-  vxdir.Transform (T);
-  vydir.Transform (T);
-}
-
-inline gp_Ax22d gp_Ax22d::Transformed(const gp_Trsf2d& T) const
-{
-  gp_Ax22d Temp = *this;
-  Temp.Transform (T);
-  return Temp;
-}
-
-inline void gp_Ax22d::Translate (const gp_Vec2d& V) 
-{ point.Translate (V); }
-
-inline gp_Ax22d gp_Ax22d::Translated(const gp_Vec2d& V) const
-{
-  gp_Ax22d Temp = *this;
-  Temp.Translate (V);
-  return Temp;
-}
-inline void gp_Ax22d::Translate (const gp_Pnt2d& P1,const gp_Pnt2d& P2)
-{ point.Translate (P1, P2); }
-
-inline gp_Ax22d gp_Ax22d::Translated (const gp_Pnt2d& P1, 
-                                     const gp_Pnt2d& P2)  const
-{
-  gp_Ax22d Temp = *this;
-  Temp.Translate (P1, P2);
-  return Temp;
-}
-
index 6fb6bdf..ae3902b 100644 (file)
@@ -18,8 +18,8 @@
 
 #define No_Standard_OutOfRange
 
-
 #include <gp_Ax2d.hxx>
+
 #include <gp_Dir2d.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_Trsf2d.hxx>
index a484c95..f034b38 100644 (file)
 #ifndef _gp_Ax2d_HeaderFile
 #define _gp_Ax2d_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
 #include <gp_Pnt2d.hxx>
 #include <gp_Dir2d.hxx>
-#include <Standard_Boolean.hxx>
-#include <Standard_Real.hxx>
-class gp_Pnt2d;
-class gp_Dir2d;
+
 class gp_Trsf2d;
 class gp_Vec2d;
 
-
-
 //! Describes an axis in the plane (2D space).
 //! An axis is defined by:
 //! -   its origin (also referred to as its "Location point"),   and
@@ -54,29 +45,30 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
-  //! Creates an axis object representing X axis of
-  //! the reference coordinate system.
-    gp_Ax2d();
-  
+  //! Creates an axis object representing X axis of the reference co-ordinate system.
+  gp_Ax2d() : loc(0.,0.)
+  //vdir(1.,0.) use default ctor of gp_Dir2d, as it creates the same dir (1,0)
+  {}
+
+  //! Creates an Ax2d.
+  //! <theP> is the "Location" point of the axis placement
+  //! and theV is the "Direction" of the axis placement.
+  gp_Ax2d (const gp_Pnt2d& theP, const gp_Dir2d& theV)
+  : loc (theP),
+    vdir (theV)
+  {}
 
-  //! Creates an Ax2d. <P> is the "Location" point of
-  //! the axis placement and V is the "Direction" of
-  //! the axis placement.
-    gp_Ax2d(const gp_Pnt2d& P, const gp_Dir2d& V);
-  
   //! Changes the "Location" point (origin) of <me>.
-    void SetLocation (const gp_Pnt2d& Locat);
-  
+  void SetLocation (const gp_Pnt2d& theP) { loc = theP; }
+
   //! Changes the direction of <me>.
-    void SetDirection (const gp_Dir2d& V);
-  
+  void SetDirection (const gp_Dir2d& theV) { vdir = theV; }
+
   //! Returns the origin of <me>.
-    const gp_Pnt2d& Location() const;
-  
+  const gp_Pnt2d& Location() const { return loc; }
+
   //! Returns the direction of <me>.
-    const gp_Dir2d& Direction() const;
-  
+  const gp_Dir2d& Direction() const { return vdir; }
 
   //! Returns True if  :
   //! . the angle between <me> and <Other> is lower or equal
@@ -87,114 +79,130 @@ public:
   //! or equal to LinearTolerance.
   Standard_EXPORT Standard_Boolean IsCoaxial (const gp_Ax2d& Other, const Standard_Real AngularTolerance, const Standard_Real LinearTolerance) const;
   
-  //! Returns true if this axis and the axis Other are normal to
-  //! each other. That is, if the angle between the two axes is equal to Pi/2 or -Pi/2.
-  //! Note: the tolerance criterion is given by AngularTolerance.
-    Standard_Boolean IsNormal (const gp_Ax2d& Other, const Standard_Real AngularTolerance) const;
-  
-  //! Returns true if this axis and the axis Other are parallel,
-  //! and have opposite orientations. That is, if the angle
-  //! between the two axes is equal to Pi or -Pi.
-  //! Note: the tolerance criterion is given by AngularTolerance.
-    Standard_Boolean IsOpposite (const gp_Ax2d& Other, const Standard_Real AngularTolerance) const;
-  
-  //! Returns true if this axis and the axis Other are parallel,
-  //! and have either the same or opposite orientations. That
-  //! is, if the angle between the two axes is equal to 0, Pi or -Pi.
-  //! Note: the tolerance criterion is given by AngularTolerance.
-    Standard_Boolean IsParallel (const gp_Ax2d& Other, const Standard_Real AngularTolerance) const;
-  
+  //! Returns true if this axis and the axis theOther are normal to each other.
+  //! That is, if the angle between the two axes is equal to Pi/2 or -Pi/2.
+  //! Note: the tolerance criterion is given by theAngularTolerance.
+  Standard_Boolean IsNormal (const gp_Ax2d& theOther, const Standard_Real theAngularTolerance) const
+  {
+    return vdir.IsNormal (theOther.vdir, theAngularTolerance);
+  }
+
+  //! Returns true if this axis and the axis theOther are parallel, and have opposite orientations. 
+  //! That is, if the angle between the two axes is equal to Pi or -Pi.
+  //! Note: the tolerance criterion is given by theAngularTolerance.
+  Standard_Boolean IsOpposite (const gp_Ax2d& theOther, const Standard_Real theAngularTolerance) const
+  {
+    return vdir.IsOpposite (theOther.vdir, theAngularTolerance);
+  }
+
+  //! Returns true if this axis and the axis theOther are parallel,
+  //! and have either the same or opposite orientations.
+  //! That is, if the angle between the two axes is equal to 0, Pi or -Pi.
+  //! Note: the tolerance criterion is given by theAngularTolerance.
+  Standard_Boolean IsParallel (const gp_Ax2d& theOther, const Standard_Real theAngularTolerance) const
+  {
+    return vdir.IsParallel (theOther.vdir, theAngularTolerance);
+  }
+
+  //! Computes the angle, in radians, between this axis and the axis theOther.
+  //! The value of the angle is between -Pi and Pi.
+  Standard_Real Angle (const gp_Ax2d& theOther) const { return vdir.Angle (theOther.vdir); }
 
-  //! Computes the angle, in radians, between this axis and
-  //! the axis Other. The value of the angle is between -Pi and Pi.
-    Standard_Real Angle (const gp_Ax2d& Other) const;
-  
   //! Reverses the direction of <me> and assigns the result to this axis.
-    void Reverse();
-  
+  void Reverse() { vdir.Reverse(); }
+
+  //! Computes a new axis placement with a direction opposite to the direction of <me>.
+  Standard_NODISCARD gp_Ax2d Reversed() const
+  { 
+    gp_Ax2d aTemp = *this;
+    aTemp.Reverse();
+    return aTemp;
+  }
 
-  //! Computes a new axis placement with a direction opposite to
-  //! the direction of <me>.
-  Standard_NODISCARD gp_Ax2d Reversed() const;
-  
   Standard_EXPORT void Mirror (const gp_Pnt2d& P);
-  
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to the point P which is the
   //! center of the symmetry.
   Standard_NODISCARD Standard_EXPORT gp_Ax2d Mirrored (const gp_Pnt2d& P) const;
-  
+
   Standard_EXPORT void Mirror (const gp_Ax2d& A);
-  
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to an axis placement which
   //! is the axis of the symmetry.
   Standard_NODISCARD Standard_EXPORT gp_Ax2d Mirrored (const gp_Ax2d& A) const;
-  
-    void Rotate (const gp_Pnt2d& P, const Standard_Real Ang);
-  
 
-  //! Rotates an axis placement. <P> is the center of the
-  //! rotation . Ang is the angular value of the rotation
-  //! in radians.
-    Standard_NODISCARD gp_Ax2d Rotated (const gp_Pnt2d& P, const Standard_Real Ang) const;
-  
+  void Rotate (const gp_Pnt2d& theP, const Standard_Real theAng)
+  {
+    loc.Rotate (theP, theAng);
+    vdir.Rotate (theAng);
+  }
+
+  //! Rotates an axis placement. <theP> is the center of the rotation.
+  //! theAng is the angular value of the rotation in radians.
+  Standard_NODISCARD gp_Ax2d Rotated (const gp_Pnt2d& theP, const Standard_Real theAng) const
+  {
+    gp_Ax2d anA = *this;
+    anA.Rotate (theP, theAng);
+    return anA;
+  }
+
   Standard_EXPORT void Scale (const gp_Pnt2d& P, const Standard_Real S);
-  
 
   //! Applies a scaling transformation on the axis placement.
   //! The "Location" point of the axisplacement is modified.
   //! The "Direction" is reversed if the scale is negative.
-  Standard_NODISCARD gp_Ax2d Scaled (const gp_Pnt2d& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf2d& T);
-  
-  //! Transforms an axis placement with a Trsf.
-    Standard_NODISCARD gp_Ax2d Transformed (const gp_Trsf2d& T) const;
-  
-    void Translate (const gp_Vec2d& V);
-  
+  Standard_NODISCARD gp_Ax2d Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const
+  {
+    gp_Ax2d anA = *this;
+    anA.Scale (theP, theS);
+    return anA;
+  }
+
+  void Transform (const gp_Trsf2d& theT)
+  {
+    loc .Transform (theT);
+    vdir.Transform (theT);
+  }
 
-  //! Translates an axis placement in the direction of the vector
-  //! <V>. The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Ax2d Translated (const gp_Vec2d& V) const;
-  
-    void Translate (const gp_Pnt2d& P1, const gp_Pnt2d& P2);
-  
-
-  //! Translates an axis placement from the point <P1> to the
-  //! point <P2>.
-    Standard_NODISCARD gp_Ax2d Translated (const gp_Pnt2d& P1, const gp_Pnt2d& P2) const;
+  //! Transforms an axis placement with a Trsf.
+  Standard_NODISCARD gp_Ax2d Transformed (const gp_Trsf2d& theT) const
+  {
+    gp_Ax2d anA = *this;
+    anA.Transform (theT);
+    return anA;
+  }
+
+  void Translate (const gp_Vec2d& theV) { loc.Translate (theV); }
+
+  //! Translates an axis placement in the direction of the vector theV.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Ax2d Translated (const gp_Vec2d& theV) const
+  {
+    gp_Ax2d anA = *this;
+    (anA.loc).Translate (theV); 
+    return anA;
+  }
+
+  void Translate (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) { loc.Translate (theP1, theP2); }
+
+  //! Translates an axis placement from the point theP1 to the point theP2.
+  Standard_NODISCARD gp_Ax2d Translated (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) const
+  {
+    gp_Ax2d anA = *this;
+    (anA.loc).Translate (gp_Vec2d (theP1, theP2));
+    return anA;
+  }
 
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
 
-
-
-
-protected:
-
-
-
-
-
 private:
 
-
-
   gp_Pnt2d loc;
   gp_Dir2d vdir;
 
-
 };
 
-
-#include <gp_Ax2d.lxx>
-
-
-
-
-
 #endif // _gp_Ax2d_HeaderFile
diff --git a/src/gp/gp_Ax2d.lxx b/src/gp/gp_Ax2d.lxx
deleted file mode 100644 (file)
index 3704862..0000000
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// Modif jcv 08/01/1991
-// JCV, LPA 07/92
-
-#include <gp_Ax2d.hxx>
-
-inline gp_Ax2d::gp_Ax2d()
-  :
-  loc(0.,0.)
-  //vdir(1.,0.) use default ctor of gp_Dir2d, as it creates the same dir (1,0)
-{ }
-
-inline gp_Ax2d::gp_Ax2d (const gp_Pnt2d& P,
-                        const gp_Dir2d& V) : loc(P), vdir(V)
-{ }
-
-inline void gp_Ax2d::SetLocation(const gp_Pnt2d& P)
-{ loc = P; }
-
-inline void gp_Ax2d::SetDirection(const gp_Dir2d& V)
-{ vdir = V; }
-
-inline const gp_Pnt2d& gp_Ax2d::Location () const
-{ return loc; }
-
-inline const gp_Dir2d& gp_Ax2d::Direction () const
-{ return vdir; }
-
-inline Standard_Boolean gp_Ax2d::IsNormal
-(const gp_Ax2d& Other,
- const Standard_Real AngularTolerance) const
-{ return vdir.IsNormal(Other.vdir, AngularTolerance); }
-
-inline Standard_Boolean gp_Ax2d::IsOpposite
-(const gp_Ax2d& Other,
- const Standard_Real AngularTolerance) const
-{ return vdir.IsOpposite (Other.vdir, AngularTolerance); }
-
-inline Standard_Boolean gp_Ax2d::IsParallel
-(const gp_Ax2d& Other,
- const Standard_Real AngularTolerance) const
-{ return vdir.IsParallel(Other.vdir, AngularTolerance); }
-
-inline   Standard_Real gp_Ax2d::Angle (const gp_Ax2d& Other) const
-{ return vdir.Angle (Other.vdir); }
-
-inline void gp_Ax2d::Reverse()
-{ vdir.Reverse(); }
-
-inline gp_Ax2d gp_Ax2d::Reversed() const
-{ 
-  gp_Ax2d Temp = *this;
-  Temp.Reverse ();
-  return Temp;
-}
-
-inline void gp_Ax2d::Rotate (const gp_Pnt2d& P,
-                            const Standard_Real Ang)
-{
-  loc.Rotate (P, Ang);
-  vdir.Rotate (Ang);
-}
-
-inline gp_Ax2d gp_Ax2d::Rotated (const gp_Pnt2d& P,
-                                const Standard_Real Ang) const
-{
-  gp_Ax2d A = *this;
-  A.Rotate (P, Ang);
-  return A;
-}
-
-inline gp_Ax2d gp_Ax2d::Scaled (const gp_Pnt2d& P,
-                               const Standard_Real S) const
-{
-  gp_Ax2d A = *this;
-  A.Scale (P, S);
-  return A;
-}
-
-inline void gp_Ax2d::Transform (const gp_Trsf2d& T)
-{
-  loc.Transform  (T);
-  vdir.Transform (T);
-}
-
-inline gp_Ax2d gp_Ax2d::Transformed (const gp_Trsf2d& T) const
-{
-  gp_Ax2d A = *this;
-  A.Transform (T);
-  return A;
-}
-
-inline void gp_Ax2d::Translate (const gp_Vec2d& V)
-{ loc.Translate (V); }
-
-inline gp_Ax2d gp_Ax2d::Translated (const gp_Vec2d& V) const
-{
-  gp_Ax2d A = *this;
-  (A.loc).Translate (V); 
-  return A;
-}
-
-inline void gp_Ax2d::Translate (const gp_Pnt2d& P1,
-                               const gp_Pnt2d& P2)
-{ loc.Translate (P1,P2); }
-
-inline gp_Ax2d gp_Ax2d::Translated (const gp_Pnt2d& P1,
-                                   const gp_Pnt2d& P2) const
-{
-  gp_Ax2d A = *this;
-  (A.loc).Translate( gp_Vec2d (P1, P2));
-  return A;
-}
-
index 6e8bd01..d02c31b 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <gp_Ax3.hxx>
 
 #include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
-#include <gp_Ax3.hxx>
 #include <gp_Dir.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Trsf.hxx>
index 80d2205..d7f69a0 100644 (file)
 #ifndef _gp_Ax3_HeaderFile
 #define _gp_Ax3_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
 #include <gp_Ax1.hxx>
+#include <gp_Ax2.hxx>
 #include <gp_Dir.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Boolean.hxx>
-class Standard_ConstructionError;
-class gp_Ax2;
-class gp_Pnt;
-class gp_Dir;
-class gp_Ax1;
-class gp_Trsf;
-class gp_Vec;
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
 
+class gp_Trsf;
 
 //! Describes a coordinate system in 3D space. Unlike a
 //! gp_Ax2 coordinate system, a gp_Ax3 can be
@@ -74,94 +65,95 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an object corresponding to the reference
   //! coordinate system (OXYZ).
-  gp_Ax3();
-  
+  gp_Ax3() : vydir (0., 1., 0.)
+  // vxdir(1.,0.,0.) use default ctor of gp_Dir, as it creates the same dir(1,0,0)
+  {}
+
   //! Creates  a  coordinate  system from a right-handed
   //! coordinate system.
-  gp_Ax3(const gp_Ax2& A);
-  
+  gp_Ax3 (const gp_Ax2& theA);
+
   //! Creates a  right handed axis placement with the
-  //! "Location"  point  P  and  two  directions, N    gives the
-  //! "Direction" and Vx gives the "XDirection".
-  //! Raises ConstructionError if N and Vx are parallel (same or opposite orientation).
-  gp_Ax3(const gp_Pnt& P, const gp_Dir& N, const gp_Dir& Vx);
-  
-
-  //! Creates an axis placement with the  "Location" point <P>
-  //! and the normal direction <V>.
-  Standard_EXPORT gp_Ax3(const gp_Pnt& P, const gp_Dir& V);
-  
+  //! "Location" point theP and  two directions, theN gives the
+  //! "Direction" and theVx gives the "XDirection".
+  //! Raises ConstructionError if theN and theVx are parallel (same or opposite orientation).
+  gp_Ax3 (const gp_Pnt& theP, const gp_Dir& theN, const gp_Dir& theVx)
+  : axis (theP, theN),
+    vydir(theN),
+    vxdir(theN)
+  {
+    vxdir.CrossCross (theVx, theN);
+    vydir.Cross (vxdir);
+  }
+
+  //! Creates an axis placement with the "Location" point <theP>
+  //! and the normal direction <theV>.
+  Standard_EXPORT gp_Ax3 (const gp_Pnt& theP, const gp_Dir& theV);
+
   //! Reverses the X direction of <me>.
-  void XReverse();
-  
+  void XReverse() { vxdir.Reverse(); }
+
   //! Reverses the Y direction of <me>.
-  void YReverse();
-  
+  void YReverse() { vydir.Reverse(); }
+
   //! Reverses the Z direction of <me>.
-  void ZReverse();
-  
-  //! Assigns the origin and "main Direction" of the axis A1 to
+  void ZReverse() { axis.Reverse(); }
+
+  //! Assigns the origin and "main Direction" of the axis theA1 to
   //! this coordinate system, then recomputes its "X Direction" and "Y Direction".
   //! Note:
   //! -   The new "X Direction" is computed as follows:
   //! new "X Direction" = V1 ^(previous "X Direction" ^ V)
-  //! where V is the "Direction" of A1.
+  //! where V is the "Direction" of theA1.
   //! -   The orientation of this coordinate system
   //! (right-handed or left-handed) is not modified.
-  //! Raises ConstructionError  if the "Direction" of <A1> and the "XDirection" of <me>
+  //! Raises ConstructionError  if the "Direction" of <theA1> and the "XDirection" of <me>
   //! are parallel (same or opposite orientation) because it is
   //! impossible to calculate the new "XDirection" and the new
   //! "YDirection".
-  void SetAxis (const gp_Ax1& A1);
-  
+  void SetAxis (const gp_Ax1& theA1);
 
   //! Changes the main direction of this coordinate system,
   //! then recomputes its "X Direction" and "Y Direction".
   //! Note:
   //! -   The new "X Direction" is computed as follows:
-  //! new "X Direction" = V ^ (previous "X Direction" ^ V).
+  //! new "X Direction" = theV ^ (previous "X Direction" ^ theV).
   //! -   The orientation of this coordinate system (left- or right-handed) is not modified.
-  //! Raises ConstructionError if <V< and the previous "XDirection" are parallel
+  //! Raises ConstructionError if <theV> and the previous "XDirection" are parallel
   //! because it is impossible to calculate the new "XDirection"
   //! and the new "YDirection".
-  void SetDirection (const gp_Dir& V);
-  
+  void SetDirection (const gp_Dir& theV);
 
   //! Changes the "Location" point (origin) of <me>.
-  void SetLocation (const gp_Pnt& P);
-  
+  void SetLocation (const gp_Pnt& theP) { axis.SetLocation (theP); }
 
   //! Changes the "Xdirection" of <me>. The main direction
   //! "Direction" is not modified, the "Ydirection" is modified.
-  //! If <Vx> is not normal to the main direction then <XDirection>
-  //! is computed as follows XDirection = Direction ^ (Vx ^ Direction).
-  //! Raises ConstructionError if <Vx> is parallel (same or opposite
+  //! If <theVx> is not normal to the main direction then <XDirection>
+  //! is computed as follows XDirection = Direction ^ (theVx ^ Direction).
+  //! Raises ConstructionError if <theVx> is parallel (same or opposite
   //! orientation) to the main direction of <me>
-  void SetXDirection (const gp_Dir& Vx);
-  
+  void SetXDirection (const gp_Dir& theVx);
 
   //! Changes the "Ydirection" of <me>. The main direction is not
   //! modified but the "Xdirection" is changed.
-  //! If <Vy> is not normal to the main direction then "YDirection"
+  //! If <theVy> is not normal to the main direction then "YDirection"
   //! is computed as  follows
-  //! YDirection = Direction ^ (<Vy> ^ Direction).
-  //! Raises ConstructionError if <Vy> is parallel to the main direction of <me>
-    void SetYDirection (const gp_Dir& Vy);
-  
+  //! YDirection = Direction ^ (<theVy> ^ Direction).
+  //! Raises ConstructionError if <theVy> is parallel to the main direction of <me>
+  void SetYDirection (const gp_Dir& theVy);
 
   //! Computes the angular value between the main direction of
-  //! <me> and the main direction of <Other>. Returns the angle
+  //! <me> and the main direction of <theOther>. Returns the angle
   //! between 0 and PI in radians.
-    Standard_Real Angle (const gp_Ax3& Other) const;
-  
+  Standard_Real Angle (const gp_Ax3& theOther) const { return axis.Angle (theOther.axis); }
 
   //! Returns the main axis of <me>. It is the "Location" point
   //! and the main "Direction".
-    const gp_Ax1& Axis() const;
-  
+  const gp_Ax1& Axis() const { return axis; }
+
   //! Computes a right-handed coordinate system with the
   //! same "X Direction" and "Y Direction" as those of this
   //! coordinate system, then recomputes the "main Direction".
@@ -169,59 +161,52 @@ public:
   //! returned is the same coordinate system. If this
   //! coordinate system is left-handed, the result is reversed.
   gp_Ax2 Ax2() const;
-  
 
   //! Returns the main direction of <me>.
-    const gp_Dir& Direction() const;
-  
+  const gp_Dir& Direction() const { return axis.Direction(); }
 
   //! Returns the "Location" point (origin) of <me>.
-    const gp_Pnt& Location() const;
-  
+  const gp_Pnt& Location() const { return axis.Location(); }
 
   //! Returns the "XDirection" of <me>.
-    const gp_Dir& XDirection() const;
-  
+  const gp_Dir& XDirection() const { return vxdir; }
 
   //! Returns the "YDirection" of <me>.
-    const gp_Dir& YDirection() const;
-  
+  const gp_Dir& YDirection() const { return vydir; }
+
   //! Returns  True if  the  coordinate  system is right-handed. i.e.
   //! XDirection().Crossed(YDirection()).Dot(Direction()) > 0
-    Standard_Boolean Direct() const;
-  
+  Standard_Boolean Direct() const { return (vxdir.Crossed (vydir).Dot (axis.Direction()) > 0.); }
 
   //! Returns True if
   //! . the distance between the "Location" point of <me> and
-  //! <Other> is lower or equal to LinearTolerance and
-  //! . the distance between the "Location" point of <Other> and
-  //! <me> is lower or equal to LinearTolerance and
+  //! <theOther> is lower or equal to theLinearTolerance and
+  //! . the distance between the "Location" point of <theOther> and
+  //! <me> is lower or equal to theLinearTolerance and
   //! . the main direction of <me> and the main direction of
-  //! <Other> are parallel (same or opposite orientation).
-    Standard_Boolean IsCoplanar (const gp_Ax3& Other, const Standard_Real LinearTolerance, const Standard_Real AngularTolerance) const;
-  
+  //! <theOther> are parallel (same or opposite orientation).
+  Standard_Boolean IsCoplanar (const gp_Ax3& theOther, const Standard_Real theLinearTolerance, const Standard_Real theAngularTolerance) const;
+
   //! Returns True if
-  //! . the distance between <me> and the "Location" point of A1
-  //! is lower of equal to LinearTolerance and
-  //! . the distance between A1 and the "Location" point of <me>
-  //! is lower or equal to LinearTolerance and
-  //! . the main direction of <me> and the direction of A1 are normal.
-    Standard_Boolean IsCoplanar (const gp_Ax1& A1, const Standard_Real LinearTolerance, const Standard_Real AngularTolerance) const;
-  
-  Standard_EXPORT void Mirror (const gp_Pnt& P);
-  
+  //! . the distance between <me> and the "Location" point of theA1
+  //! is lower of equal to theLinearTolerance and
+  //! . the distance between theA1 and the "Location" point of <me>
+  //! is lower or equal to theLinearTolerance and
+  //! . the main direction of <me> and the direction of theA1 are normal.
+  Standard_Boolean IsCoplanar (const gp_Ax1& theA1, const Standard_Real theLinearTolerance, const Standard_Real theAngularTolerance) const;
+
+  Standard_EXPORT void Mirror (const gp_Pnt& theP);
 
   //! Performs the symmetrical transformation of an axis
-  //! placement with respect to the point P which is the
+  //! placement with respect to the point theP which is the
   //! center of the symmetry.
   //! Warnings :
   //! The main direction of the axis placement is not changed.
   //! The "XDirection" and the "YDirection" are reversed.
   //! So the axis placement stay right handed.
-  Standard_NODISCARD Standard_EXPORT gp_Ax3 Mirrored (const gp_Pnt& P) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax1& A1);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Ax3 Mirrored (const gp_Pnt& theP) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax1& theA1);
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to an axis placement which
@@ -230,65 +215,96 @@ public:
   //! point, on the "XDirection" and "YDirection".
   //! The resulting main "Direction" is the cross product between
   //! the "XDirection" and the "YDirection" after transformation.
-  Standard_NODISCARD Standard_EXPORT gp_Ax3 Mirrored (const gp_Ax1& A1) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2& A2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Ax3 Mirrored (const gp_Ax1& theA1) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2& theA2);
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to a plane.
-  //! The axis placement  <A2> locates the plane of the symmetry :
+  //! The axis placement  <theA2> locates the plane of the symmetry :
   //! (Location, XDirection, YDirection).
   //! The transformation is performed on the "Location"
   //! point, on the "XDirection" and "YDirection".
   //! The resulting main "Direction" is the cross product between
   //! the "XDirection" and the "YDirection" after transformation.
-  Standard_NODISCARD Standard_EXPORT gp_Ax3 Mirrored (const gp_Ax2& A2) const;
-  
-  void Rotate (const gp_Ax1& A1, const Standard_Real Ang);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Ax3 Mirrored (const gp_Ax2& theA2) const;
 
-  //! Rotates an axis placement. <A1> is the axis of the
-  //! rotation . Ang is the angular value of the rotation
+  void Rotate (const gp_Ax1& theA1, const Standard_Real theAng)
+  {
+    axis.Rotate (theA1, theAng);
+    vxdir.Rotate (theA1, theAng);
+    vydir.Rotate (theA1, theAng);
+  }
+
+  //! Rotates an axis placement. <theA1> is the axis of the
+  //! rotation . theAng is the angular value of the rotation
   //! in radians.
-  Standard_NODISCARD gp_Ax3 Rotated (const gp_Ax1& A1, const Standard_Real Ang) const;
-  
-  void Scale (const gp_Pnt& P, const Standard_Real S);
-  
+  Standard_NODISCARD gp_Ax3 Rotated (const gp_Ax1& theA1, const Standard_Real theAng) const
+  {
+    gp_Ax3 aTemp = *this;
+    aTemp.Rotate (theA1, theAng);
+    return aTemp;
+  }
+
+  void Scale (const gp_Pnt& theP, const Standard_Real theS)
+  {
+    axis.Scale (theP, theS);
+    if (theS < 0.)
+    {
+      vxdir.Reverse();
+      vydir.Reverse();
+    }
+  }
 
   //! Applies a scaling transformation on the axis placement.
   //! The "Location" point of the axisplacement is modified.
   //! Warnings :
-  //! If the scale <S> is negative :
+  //! If the scale <theS> is negative :
   //! . the main direction of the axis placement is not changed.
   //! . The "XDirection" and the "YDirection" are reversed.
   //! So the axis placement stay right handed.
-  Standard_NODISCARD gp_Ax3 Scaled (const gp_Pnt& P, const Standard_Real S) const;
-  
-  void Transform (const gp_Trsf& T);
-  
+  Standard_NODISCARD gp_Ax3 Scaled (const gp_Pnt& theP, const Standard_Real theS) const
+  {
+    gp_Ax3 aTemp = *this;
+    aTemp.Scale (theP, theS);
+    return aTemp;
+  }
+
+  void Transform (const gp_Trsf& theT)
+  {
+    axis.Transform (theT);
+    vxdir.Transform (theT);
+    vydir.Transform (theT);
+  }
 
   //! Transforms an axis placement with a Trsf.
   //! The "Location" point, the "XDirection" and the
-  //! "YDirection" are transformed with T.  The resulting
+  //! "YDirection" are transformed with theT.  The resulting
   //! main "Direction" of <me> is the cross product between
   //! the "XDirection" and the "YDirection" after transformation.
-  Standard_NODISCARD gp_Ax3 Transformed (const gp_Trsf& T) const;
-  
-  void Translate (const gp_Vec& V);
-  
+  Standard_NODISCARD gp_Ax3 Transformed (const gp_Trsf& theT) const
+  {
+    gp_Ax3 aTemp = *this;
+    aTemp.Transform (theT);
+    return aTemp;
+  }
+
+  void Translate (const gp_Vec& theV) { axis.Translate (theV); }
 
   //! Translates an axis plaxement in the direction of the vector
-  //! <V>. The magnitude of the translation is the vector's magnitude.
-  Standard_NODISCARD gp_Ax3 Translated (const gp_Vec& V) const;
-  
-  void Translate (const gp_Pnt& P1, const gp_Pnt& P2);
-  
+  //! <theV>. The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Ax3 Translated (const gp_Vec& theV) const
+  {
+    gp_Ax3 aTemp = *this;
+    aTemp.Translate (theV);
+    return aTemp;
+  }
 
-  //! Translates an axis placement from the point <P1> to the
-  //! point <P2>.
-  Standard_NODISCARD gp_Ax3 Translated (const gp_Pnt& P1, const gp_Pnt& P2) const;
+  void Translate (const gp_Pnt& theP1, const gp_Pnt& theP2) { Translate (gp_Vec (theP1, theP2)); }
 
+  //! Translates an axis placement from the point <theP1> to the
+  //! point <theP2>.
+  Standard_NODISCARD gp_Ax3 Translated (const gp_Pnt& theP1, const gp_Pnt& theP2) const { return Translated (gp_Vec (theP1, theP2)); }
 
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
@@ -296,28 +312,153 @@ public:
   //! Inits the content of me from the stream
   Standard_EXPORT Standard_Boolean InitFromJson (const Standard_SStream& theSStream, Standard_Integer& theStreamPos);
 
-protected:
-
-
-
-
-
 private:
 
-
-
   gp_Ax1 axis;
   gp_Dir vydir;
   gp_Dir vxdir;
 
-
 };
 
-
-#include <gp_Ax3.lxx>
-
-
-
-
+// =======================================================================
+// function : gp_Ax3
+// purpose  :
+// =======================================================================
+inline gp_Ax3::gp_Ax3 (const gp_Ax2& theA)
+: axis (theA.Axis()),
+  vydir (theA.YDirection()),
+  vxdir (theA.XDirection())
+{}
+
+// =======================================================================
+// function : Ax2
+// purpose  :
+// =======================================================================
+inline gp_Ax2  gp_Ax3::Ax2()const
+{
+  gp_Dir aZz = axis.Direction();
+  if (!Direct())
+  {
+    aZz.Reverse();
+  }
+  return gp_Ax2 (axis.Location(), aZz, vxdir);
+}
+
+// =======================================================================
+// function : SetAxis
+// purpose  :
+// =======================================================================
+inline void  gp_Ax3::SetAxis (const gp_Ax1& theA1)
+{
+  Standard_Boolean isDirect = Direct();
+  axis = theA1;
+  vxdir = axis.Direction().CrossCrossed (vxdir, axis.Direction());
+  if (isDirect)
+  {
+    vydir = axis.Direction().Crossed (vxdir);
+  }
+  else
+  {
+    vydir = vxdir.Crossed (axis.Direction());
+  }
+}
+
+// =======================================================================
+// function : SetDirection
+// purpose  :
+// =======================================================================
+inline void  gp_Ax3::SetDirection (const gp_Dir& theV)
+{
+  Standard_Boolean isDirect = Direct();
+  axis.SetDirection (theV);
+  vxdir = theV.CrossCrossed (vxdir, theV);
+  if (isDirect)
+  {
+    vydir = theV.Crossed (vxdir);
+  }
+  else
+  {
+    vydir = vxdir.Crossed (theV);
+  }
+}
+
+// =======================================================================
+// function : SetXDirection
+// purpose  :
+// =======================================================================
+inline void  gp_Ax3::SetXDirection (const gp_Dir& theVx)
+{
+  Standard_Boolean isDirect = Direct();
+  vxdir = axis.Direction().CrossCrossed (theVx, axis.Direction());
+  if (isDirect)
+  {
+    vydir = axis.Direction().Crossed (vxdir);
+  }
+  else
+  {
+    vydir = vxdir.Crossed (axis.Direction());
+  }
+}
+
+// =======================================================================
+// function : SetYDirection
+// purpose  :
+// =======================================================================
+inline void  gp_Ax3::SetYDirection (const gp_Dir& theVy)
+{
+  Standard_Boolean isDirect = Direct();
+  vxdir = theVy.Crossed (axis.Direction());
+  vydir = (axis.Direction()).Crossed (vxdir);
+  if (!isDirect)
+  {
+    vxdir.Reverse();
+  }
+}
+
+// =======================================================================
+// function : IsCoplanar
+// purpose  :
+// =======================================================================
+inline Standard_Boolean gp_Ax3::IsCoplanar (const gp_Ax3& theOther, 
+                                            const Standard_Real theLinearTolerance,
+                                            const Standard_Real theAngularTolerance)const
+{
+  gp_Vec aVec (axis.Location(), theOther.axis.Location());
+  Standard_Real aD1 = gp_Vec (axis.Direction()).Dot(aVec);
+  if (aD1 < 0)
+  {
+    aD1 = -aD1;
+  }
+  Standard_Real aD2 = gp_Vec (theOther.axis.Direction()).Dot(aVec);
+  if (aD2 < 0)
+  {
+    aD2 = -aD2;
+  }
+  return (aD1 <= theLinearTolerance && aD2 <= theLinearTolerance &&
+          axis.IsParallel (theOther.axis, theAngularTolerance));
+}
+
+// =======================================================================
+// function : IsCoplanar
+// purpose  :
+// =======================================================================
+inline Standard_Boolean gp_Ax3::IsCoplanar (const gp_Ax1& theA1,
+                                            const Standard_Real theLinearTolerance,
+                                            const Standard_Real theAngularTolerance)const
+{
+  gp_Vec aVec (axis.Location(), theA1.Location());
+  Standard_Real aD1 = gp_Vec (axis.Direction()).Dot (aVec);
+  if (aD1 < 0)
+  {
+    aD1 = -aD1;
+  }
+  Standard_Real aD2 = (gp_Vec (theA1.Direction()).Crossed (aVec)).Magnitude();
+  if (aD2 < 0)
+  {
+    aD2 = -aD2;
+  }
+  return (aD1 <= theLinearTolerance && aD2 <= theLinearTolerance &&
+          axis.IsNormal (theA1, theAngularTolerance));
+}
 
 #endif // _gp_Ax3_HeaderFile
diff --git a/src/gp/gp_Ax3.lxx b/src/gp/gp_Ax3.lxx
deleted file mode 100644 (file)
index 2b4fe6d..0000000
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright (c) 1996-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp_Ax2.hxx>
-
-inline gp_Ax3::gp_Ax3()
-  :
-  vydir(0.,1.,0.)
-  // vxdir(1.,0.,0.) use default ctor of gp_Dir, as it creates the same dir(1,0,0)
-{ }
-
-inline gp_Ax3::gp_Ax3(const gp_Ax2& A) :
-axis(A.Axis()),
-vydir(A.YDirection()),
-vxdir(A.XDirection())
-{ }
-
-inline gp_Ax3::gp_Ax3(const gp_Pnt& P, const gp_Dir& N, const gp_Dir& Vx) :
-axis(P, N), vydir(N), vxdir(N)
-{
-  vxdir.CrossCross(Vx, N);
-  vydir.Cross(vxdir);
-}
-
-inline void  gp_Ax3::XReverse()
-{ vxdir.Reverse(); }
-
-inline void  gp_Ax3::YReverse()
-{ vydir.Reverse(); }
-
-inline void  gp_Ax3::ZReverse()
-{ axis.Reverse();  }
-
-inline void  gp_Ax3::SetAxis(const gp_Ax1& A1)
-{
-  Standard_Boolean direct = Direct();
-  axis = A1;
-  vxdir = axis.Direction().CrossCrossed (vxdir, axis.Direction());
-  if(direct) { vydir = axis.Direction().Crossed(vxdir); }
-  else       { vydir = vxdir.Crossed(axis.Direction()); }
-}
-
-inline void  gp_Ax3::SetDirection(const gp_Dir& V)
-{
-  Standard_Boolean direct = Direct();
-  axis.SetDirection (V);
-  vxdir = V.CrossCrossed (vxdir, V);
-  if (direct) { vydir = V.Crossed (vxdir); }
-  else        { vydir = vxdir.Crossed (V); }
-}
-
-inline void  gp_Ax3::SetLocation(const gp_Pnt& P)
-{  axis.SetLocation(P); }
-
-inline void  gp_Ax3::SetXDirection(const gp_Dir& Vx)
-{
-  Standard_Boolean direct = Direct();
-  vxdir = axis.Direction().CrossCrossed (Vx, axis.Direction());
-  if (direct) { vydir = axis.Direction().Crossed(vxdir); }
-  else        { vydir = vxdir.Crossed(axis.Direction()); }
-}
-
-inline void  gp_Ax3::SetYDirection(const gp_Dir& Vy)
-{
-  Standard_Boolean direct = Direct();
-  vxdir = Vy.Crossed (axis.Direction());
-  vydir = (axis.Direction()).Crossed (vxdir);
-  if (!direct) { vxdir.Reverse(); }
-}
-
-inline Standard_Real  gp_Ax3::Angle(const gp_Ax3& Other) const 
-{ return axis.Angle (Other.axis); }
-
-inline const gp_Ax1&  gp_Ax3::Axis()const
-{  return axis; }
-
-inline gp_Ax2  gp_Ax3::Ax2()const 
-{
-  gp_Dir zz = axis.Direction();
-  if (!Direct()) { zz.Reverse(); }
-  return gp_Ax2 (axis.Location(),zz,vxdir);
-}
-
-inline const gp_Dir&  gp_Ax3::Direction()const
-{   return axis.Direction(); }
-
-inline const gp_Pnt&  gp_Ax3::Location()const
-{   return axis.Location(); }
-
-inline const gp_Dir&  gp_Ax3::XDirection()const
-{  return vxdir;  }
-
-inline const gp_Dir&  gp_Ax3::YDirection()const
-{  return vydir; }
-
-inline Standard_Boolean  gp_Ax3::Direct()const 
-{ return (vxdir.Crossed(vydir).Dot(axis.Direction()) > 0.); }
-
-inline Standard_Boolean gp_Ax3::IsCoplanar
-(const gp_Ax3& Other, 
- const Standard_Real LinearTolerance, 
- const Standard_Real AngularTolerance)const 
-{
-  gp_Vec vec(axis.Location(),Other.axis.Location());
-  Standard_Real D1 = gp_Vec(axis.Direction()      ).Dot(vec);
-  if (D1 < 0) D1 = - D1;
-  Standard_Real D2 = gp_Vec(Other.axis.Direction()).Dot(vec);
-  if (D2 < 0) D2 = - D2;
-  return (D1 <= LinearTolerance && D2 <= LinearTolerance &&
-          axis.IsParallel (Other.axis, AngularTolerance));
-}
-
-inline Standard_Boolean gp_Ax3::IsCoplanar
-(const gp_Ax1& A1, 
- const Standard_Real LinearTolerance, 
- const Standard_Real AngularTolerance)const 
-{
-  gp_Vec vec(axis.Location(),A1.Location());
-  Standard_Real D1 = gp_Vec(axis.Direction()).Dot(vec);
-  if (D1 < 0) D1 = - D1;
-  Standard_Real D2 = (gp_Vec(A1.Direction()).Crossed(vec)).Magnitude();
-  if (D2 < 0) D2 = - D2;
-  return (D1 <= LinearTolerance && D2 <= LinearTolerance &&
-          axis.IsNormal (A1, AngularTolerance));
-}
-
-inline void  gp_Ax3::Rotate(const gp_Ax1& A1,
-                           const Standard_Real Ang)
-{
-  axis.Rotate (A1,Ang);
-  vxdir.Rotate (A1,Ang);
-  vydir.Rotate (A1,Ang);
-}
-
-inline gp_Ax3  gp_Ax3::Rotated(const gp_Ax1& A1,
-                              const Standard_Real Ang)const
-{
-  gp_Ax3 Temp = *this;
-  Temp.Rotate (A1,Ang);
-  return Temp;
-}
-
-inline void  gp_Ax3::Scale(const gp_Pnt& P, const Standard_Real S)
-{
-  axis.Scale (P,S);
-  if (S < 0.) {
-    vxdir.Reverse ();
-    vydir.Reverse ();
-  }
-}
-
-inline gp_Ax3  gp_Ax3::Scaled(const gp_Pnt& P,
-                             const Standard_Real S)const
-{
-  gp_Ax3 Temp = *this;
-  Temp.Scale (P,S);
-  return Temp;
-}
-
-inline void  gp_Ax3::Transform(const gp_Trsf& T)
-{
-  axis.Transform (T);
-  vxdir.Transform (T);
-  vydir.Transform (T);
-}
-
-inline gp_Ax3  gp_Ax3::Transformed(const gp_Trsf& T)const
-{
-  gp_Ax3 Temp = *this;
-  Temp.Transform (T);
-  return Temp;
-}
-
-inline void  gp_Ax3::Translate(const gp_Vec& V)
-{ axis.Translate (V); }
-
-inline gp_Ax3  gp_Ax3::Translated(const gp_Vec& V)const
-{
-  gp_Ax3 Temp = *this;
-  Temp.Translate (V);
-  return Temp;
-}
-
-inline void  gp_Ax3::Translate(const gp_Pnt& P1, const gp_Pnt& P2)
-{ Translate(gp_Vec(P1,P2)); }
-
-inline gp_Ax3  gp_Ax3::Translated(const gp_Pnt& P1, const gp_Pnt& P2)const
-{ return Translated(gp_Vec(P1,P2)); }
-
index bd859ac..baae99e 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <gp_Circ.hxx>
 
 #include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
-#include <gp_Circ.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Trsf.hxx>
 #include <gp_Vec.hxx>
index 1347755..524767f 100644 (file)
 #ifndef _gp_Circ_HeaderFile
 #define _gp_Circ_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <gp_Ax2.hxx>
-#include <Standard_Real.hxx>
 #include <gp_Ax1.hxx>
-#include <Standard_Boolean.hxx>
-class Standard_ConstructionError;
-class gp_Ax2;
-class gp_Ax1;
-class gp_Pnt;
-class gp_Trsf;
-class gp_Vec;
-
-
+#include <gp_Ax2.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_Vec.hxx>
+#include <Standard_ConstructionError.hxx>
 
 //! Describes a circle in 3D space.
 //! A circle is defined by its radius and positioned in space
@@ -64,173 +54,227 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an indefinite circle.
-    gp_Circ();
-  
+  gp_Circ() : radius (RealLast())
+  {}
 
   //! A2 locates the circle and gives its orientation in 3D space.
   //! Warnings :
-  //! It is not forbidden to create a circle with Radius = 0.0  Raises ConstructionError if Radius < 0.0
-    gp_Circ(const gp_Ax2& A2, const Standard_Real Radius);
-  
+  //! It is not forbidden to create a circle with theRadius = 0.0  Raises ConstructionError if theRadius < 0.0
+  gp_Circ (const gp_Ax2& theA2, const Standard_Real theRadius)
+  : pos (theA2),
+    radius(theRadius)
+  {
+    Standard_ConstructionError_Raise_if (theRadius < 0.0, "gp_Circ() - radius should be positive number");
+  }
 
   //! Changes the main axis of the circle. It is the axis
   //! perpendicular to the plane of the circle.
-  //! Raises ConstructionError if the direction of A1
+  //! Raises ConstructionError if the direction of theA1
   //! is parallel to the "XAxis" of the circle.
-    void SetAxis (const gp_Ax1& A1);
-  
+  void SetAxis (const gp_Ax1& theA1) { pos.SetAxis (theA1); }
 
   //! Changes the "Location" point (center) of the circle.
-    void SetLocation (const gp_Pnt& P);
-  
+  void SetLocation (const gp_Pnt& theP) { pos.SetLocation (theP); }
+
   //! Changes the position of the circle.
-    void SetPosition (const gp_Ax2& A2);
-  
+  void SetPosition (const gp_Ax2& theA2) { pos = theA2; }
+
   //! Modifies the radius of this circle.
-  //! Warning. This class does not prevent the creation of a circle where Radius is null.
+  //! Warning. This class does not prevent the creation of a circle where theRadius is null.
   //! Exceptions
-  //! Standard_ConstructionError if Radius is negative.
-    void SetRadius (const Standard_Real Radius);
-  
+  //! Standard_ConstructionError if theRadius is negative.
+  void SetRadius (const Standard_Real theRadius)
+  {
+    Standard_ConstructionError_Raise_if (theRadius < 0.0, "gp_Circ::SetRadius() - radius should be positive number");
+    radius = theRadius;
+  }
+
   //! Computes the area of the circle.
-    Standard_Real Area() const;
-  
+  Standard_Real Area() const { return M_PI * radius * radius; }
 
   //! Returns the main axis of the circle.
   //! It is the axis perpendicular to the plane of the circle,
   //! passing through the "Location" point (center) of the circle.
-    const gp_Ax1& Axis() const;
-  
+  const gp_Ax1& Axis() const { return pos.Axis(); }
+
   //! Computes the circumference of the circle.
-    Standard_Real Length() const;
-  
+  Standard_Real Length() const { return 2. * M_PI * radius; }
 
   //! Returns the center of the circle. It is the
   //! "Location" point of the local coordinate system
   //! of the circle
-    const gp_Pnt& Location() const;
-  
+  const gp_Pnt& Location() const { return pos.Location(); }
 
   //! Returns the position of the circle.
   //! It is the local coordinate system of the circle.
-    const gp_Ax2& Position() const;
-  
+  const gp_Ax2& Position() const { return pos; }
+
   //! Returns the radius of this circle.
-    Standard_Real Radius() const;
-  
+  Standard_Real Radius() const { return radius; }
 
   //! Returns the "XAxis" of the circle.
   //! This axis is perpendicular to the axis of the conic.
   //! This axis and the "Yaxis" define the plane of the conic.
-    gp_Ax1 XAxis() const;
-  
+  gp_Ax1 XAxis() const { return gp_Ax1 (pos.Location(), pos.XDirection()); }
 
   //! Returns the "YAxis" of the circle.
   //! This axis and the "Xaxis" define the plane of the conic.
   //! The "YAxis" is perpendicular to the "Xaxis".
-    gp_Ax1 YAxis() const;
-  
+  gp_Ax1 YAxis() const { return gp_Ax1 (pos.Location(), pos.YDirection()); }
 
-  //! Computes the minimum of distance between the point P and
+  //! Computes the minimum of distance between the point theP and
   //! any point on the circumference of the circle.
-    Standard_Real Distance (const gp_Pnt& P) const;
-  
-
-  //! Computes the square distance between <me> and the point P.
-    Standard_Real SquareDistance (const gp_Pnt& P) const;
-  
-
-  //! Returns True if the point P is on the circumference.
-  //! The distance between <me> and <P> must be lower or
-  //! equal to LinearTolerance.
-    Standard_Boolean Contains (const gp_Pnt& P, const Standard_Real LinearTolerance) const;
-  
-  Standard_EXPORT void Mirror (const gp_Pnt& P);
-  
+  Standard_Real Distance (const gp_Pnt& theP) const { return sqrt (SquareDistance (theP)); }
+
+  //! Computes the square distance between <me> and the point theP.
+  Standard_Real SquareDistance (const gp_Pnt& theP) const
+  {
+    gp_Vec aV (Location(), theP);
+    Standard_Real aX = aV.Dot (pos.XDirection());
+    Standard_Real anY = aV.Dot (pos.YDirection());
+    Standard_Real aZ = aV.Dot (pos.Direction());
+    Standard_Real aT = sqrt (aX * aX + anY * anY) - radius;
+    return (aT * aT + aZ * aZ);
+  }
+
+  //! Returns True if the point theP is on the circumference.
+  //! The distance between <me> and <theP> must be lower or
+  //! equal to theLinearTolerance.
+  Standard_Boolean Contains (const gp_Pnt& theP, const Standard_Real theLinearTolerance) const { return Distance (theP) <= theLinearTolerance; }
+
+  Standard_EXPORT void Mirror (const gp_Pnt& theP);
 
   //! Performs the symmetrical transformation of a circle
-  //! with respect to the point P which is the center of the
+  //! with respect to the point theP which is the center of the
   //! symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Circ Mirrored (const gp_Pnt& P) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax1& A1);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Circ Mirrored (const gp_Pnt& theP) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax1& theA1);
 
   //! Performs the symmetrical transformation of a circle with
   //! respect to an axis placement which is the axis of the
   //! symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Circ Mirrored (const gp_Ax1& A1) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2& A2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Circ Mirrored (const gp_Ax1& theA1) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2& theA2);
 
   //! Performs the symmetrical transformation of a circle with respect
-  //! to a plane. The axis placement A2 locates the plane of the
+  //! to a plane. The axis placement theA2 locates the plane of the
   //! of the symmetry : (Location, XDirection, YDirection).
-  Standard_NODISCARD Standard_EXPORT gp_Circ Mirrored (const gp_Ax2& A2) const;
-  
-    void Rotate (const gp_Ax1& A1, const Standard_Real Ang);
-  
-
-  //! Rotates a circle. A1 is the axis of the rotation.
-  //! Ang is the angular value of the rotation in radians.
-    Standard_NODISCARD gp_Circ Rotated (const gp_Ax1& A1, const Standard_Real Ang) const;
-  
-    void Scale (const gp_Pnt& P, const Standard_Real S);
-  
-
-  //! Scales a circle. S is the scaling value.
-  //! Warnings :
-  //! If S is negative the radius stay positive but
-  //! the "XAxis" and the "YAxis" are  reversed as for
-  //! an ellipse.
-    Standard_NODISCARD gp_Circ Scaled (const gp_Pnt& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf& T);
-  
-
-  //! Transforms a circle with the transformation T from class Trsf.
-    Standard_NODISCARD gp_Circ Transformed (const gp_Trsf& T) const;
-  
-    void Translate (const gp_Vec& V);
-  
-
-  //! Translates a circle in the direction of the vector V.
-  //! The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Circ Translated (const gp_Vec& V) const;
-  
-    void Translate (const gp_Pnt& P1, const gp_Pnt& P2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Circ Mirrored (const gp_Ax2& theA2) const;
 
-  //! Translates a circle from the point P1 to the point P2.
-    Standard_NODISCARD gp_Circ Translated (const gp_Pnt& P1, const gp_Pnt& P2) const;
+  void Rotate (const gp_Ax1& theA1, const Standard_Real theAng) { pos.Rotate (theA1, theAng); }
 
+  //! Rotates a circle. theA1 is the axis of the rotation.
+  //! theAng is the angular value of the rotation in radians.
+  Standard_NODISCARD gp_Circ Rotated (const gp_Ax1& theA1, const Standard_Real theAng) const
+  {
+    gp_Circ aC = *this;
+    aC.pos.Rotate (theA1, theAng);
+    return aC;
+  }
 
+  void Scale (const gp_Pnt& theP, const Standard_Real theS);
 
+  //! Scales a circle. theS is the scaling value.
+  //! Warnings :
+  //! If theS is negative the radius stay positive but
+  //! the "XAxis" and the "YAxis" are  reversed as for
+  //! an ellipse.
+  Standard_NODISCARD gp_Circ Scaled (const gp_Pnt& theP, const Standard_Real theS) const;
 
-protected:
-
+  void Transform (const gp_Trsf& theT);
 
+  //! Transforms a circle with the transformation theT from class Trsf.
+  Standard_NODISCARD gp_Circ Transformed (const gp_Trsf& theT) const;
 
+  void Translate (const gp_Vec& theV) { pos.Translate (theV); }
 
+  //! Translates a circle in the direction of the vector theV.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Circ Translated (const gp_Vec& theV) const
+  {
+    gp_Circ aC = *this;
+    aC.pos.Translate (theV);
+    return aC;
+  }
+
+  void Translate (const gp_Pnt& theP1, const gp_Pnt& theP2) { pos.Translate (theP1, theP2); }
+
+  //! Translates a circle from the point theP1 to the point theP2.
+  Standard_NODISCARD gp_Circ Translated (const gp_Pnt& theP1, const gp_Pnt& theP2) const
+  {
+    gp_Circ aC = *this;
+    aC.pos.Translate (theP1, theP2);
+    return aC;
+  }
 
 private:
 
-
-
   gp_Ax2 pos;
   Standard_Real radius;
 
-
 };
 
-
-#include <gp_Circ.lxx>
-
-
-
-
+// =======================================================================
+// function : Scale
+// purpose  :
+// =======================================================================
+inline void gp_Circ::Scale (const gp_Pnt& theP, const Standard_Real theS)
+{
+  radius *= theS;
+  if (radius < 0)
+  {
+    radius = -radius;
+  }
+  pos.Scale (theP, theS);
+}
+
+// =======================================================================
+// function : Scaled
+// purpose  :
+// =======================================================================
+inline gp_Circ gp_Circ::Scaled (const gp_Pnt& theP, const Standard_Real theS) const
+{
+  gp_Circ aC = *this;
+  aC.radius *= theS;
+  if (aC.radius < 0)
+  {
+    aC.radius = -aC.radius;
+  }
+  aC.pos.Scale (theP, theS);
+  return aC;
+}
+
+// =======================================================================
+// function : Transform
+// purpose  :
+// =======================================================================
+inline void gp_Circ::Transform (const gp_Trsf& theT)
+{
+  radius *= theT.ScaleFactor();
+  if (radius < 0)
+  {
+    radius = -radius;
+  }
+  pos.Transform (theT);
+}
+
+// =======================================================================
+// function : Transformed
+// purpose  :
+// =======================================================================
+inline gp_Circ gp_Circ::Transformed (const gp_Trsf& theT) const
+{
+  gp_Circ aC = *this;
+  aC.radius *= theT.ScaleFactor();
+  if (aC.radius < 0)
+  {
+    aC.radius = -aC.radius;
+  }
+  aC.pos.Transform (theT);
+  return aC;
+}
 
 #endif // _gp_Circ_HeaderFile
diff --git a/src/gp/gp_Circ.lxx b/src/gp/gp_Circ.lxx
deleted file mode 100644 (file)
index 39006dc..0000000
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_ConstructionError.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Ax1.hxx>
-#include <gp_Ax2.hxx>
-
-inline gp_Circ::gp_Circ () : radius(RealLast())
-{  }
-
-inline gp_Circ::gp_Circ (const gp_Ax2& A2,
-                        const Standard_Real R) : pos(A2), radius(R)
-{
-  Standard_ConstructionError_Raise_if (R < 0.0, "gp_Circ() - radius should be positive number");
-}
-
-inline void gp_Circ::SetAxis (const gp_Ax1& A1)
-{ pos.SetAxis (A1); }
-
-inline void gp_Circ::SetLocation (const gp_Pnt& P)
-{ pos.SetLocation (P); }
-
-inline void gp_Circ::SetPosition (const gp_Ax2& A2)
-{ pos = A2; }
-
-inline void gp_Circ::SetRadius (const Standard_Real R)
-{ 
-  Standard_ConstructionError_Raise_if (R < 0.0, "gp_Circ::SetRadius() - radius should be positive number");
-  radius = R;
-}
-
-inline   Standard_Real gp_Circ::Area() const
-{ return M_PI * radius * radius; }
-
-inline const gp_Ax1& gp_Circ::Axis () const
-{ return pos.Axis(); }
-
-inline   Standard_Real gp_Circ::Length() const
-{ return 2. * M_PI * radius; }
-
-inline const gp_Pnt& gp_Circ::Location () const
-{ return pos.Location(); }
-
-inline   const gp_Ax2& gp_Circ::Position() const
-{ return pos; }
-
-inline   Standard_Real gp_Circ::Radius() const
-{ return radius; }
-
-inline gp_Ax1 gp_Circ::XAxis () const
-{return gp_Ax1(pos.Location(), pos.XDirection());}
-
-inline gp_Ax1 gp_Circ::YAxis () const
-{return gp_Ax1(pos.Location(), pos.YDirection());}
-
-inline Standard_Real gp_Circ::Distance (const gp_Pnt& P) const
-{ return sqrt(SquareDistance(P)); }
-
-inline Standard_Real gp_Circ::SquareDistance (const gp_Pnt& P) const
-{
-  gp_Vec V(Location(),P);
-  Standard_Real x = V.Dot(pos.XDirection());
-  Standard_Real y = V.Dot(pos.YDirection());
-  Standard_Real z = V.Dot(pos.Direction ());
-  Standard_Real t = sqrt( x*x + y*y) - radius;
-  return (t*t + z*z);
-}
-
-inline Standard_Boolean gp_Circ::Contains
-(const gp_Pnt& P,
- const Standard_Real LinearTolerance) const
-{ return Distance(P) <= LinearTolerance; }
-
-inline void gp_Circ::Rotate (const gp_Ax1& A1,
-                            const Standard_Real Ang)
-{ pos.Rotate(A1, Ang); }
-
-inline gp_Circ gp_Circ::Rotated (const gp_Ax1& A1,
-                                const Standard_Real Ang) const
-{
-  gp_Circ C = *this;
-  C.pos.Rotate(A1, Ang);
-  return C; 
-}
-
-inline void gp_Circ::Scale (const gp_Pnt& P,
-                           const Standard_Real S)
-{
-  radius *= S;
-  if (radius < 0) radius = - radius;
-  pos.Scale(P, S);
-}
-
-inline gp_Circ gp_Circ::Scaled (const gp_Pnt& P,
-                               const Standard_Real S) const 
-{
-  gp_Circ C = *this;
-  C.radius *= S;
-  if (C.radius < 0) C.radius = - C.radius;
-  C.pos.Scale(P, S);
-  return C; 
-}
-
-inline void gp_Circ::Transform (const gp_Trsf& T)
-{
-  radius *= T.ScaleFactor();
-  if (radius < 0) radius = - radius;
-  pos.Transform(T);
-}
-
-inline gp_Circ gp_Circ::Transformed (const gp_Trsf& T) const
-{
-  gp_Circ C = *this;
-  C.radius *= T.ScaleFactor();
-  if (C.radius < 0) C.radius = - C.radius;
-  C.pos.Transform(T);
-  return C;
-}
-
-inline void gp_Circ::Translate (const gp_Vec& V)
-{ pos.Translate(V); }
-
-inline gp_Circ gp_Circ::Translated (const gp_Vec& V) const 
-{
-  gp_Circ C = *this;
-  C.pos.Translate(V);
-  return C; 
-}
-
-inline void gp_Circ::Translate (const gp_Pnt& P1,
-                               const gp_Pnt& P2)
-{pos.Translate(P1,P2);}
-
-inline gp_Circ gp_Circ::Translated (const gp_Pnt& P1,
-                                   const gp_Pnt& P2) const
-{
-  gp_Circ C = *this;
-  C.pos.Translate(P1, P2);
-  return C; 
-}
-
index 64cfca9..0a24ad3 100644 (file)
 
 //modif JCV 10/01/91 suite a la deuxieme revue de projet toolkit geometry
 
+#include <gp_Circ2d.hxx>
+
 #include <gp_Ax2d.hxx>
 #include <gp_Ax22d.hxx>
-#include <gp_Circ2d.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_Trsf2d.hxx>
 #include <gp_Vec2d.hxx>
index 8cf4047..5a81645 100644 (file)
 #ifndef _gp_Circ2d_HeaderFile
 #define _gp_Circ2d_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>
-class Standard_ConstructionError;
-class gp_Ax2d;
-class gp_Ax22d;
-class gp_Pnt2d;
-class gp_Trsf2d;
-class gp_Vec2d;
-
+#include <gp_Pnt2d.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <Standard_ConstructionError.hxx>
 
 //! Describes a circle in the plane (2D space).
 //! A circle is defined by its radius and positioned in the
@@ -61,181 +52,318 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! creates an indefinite circle.
-    gp_Circ2d();
-  
+  gp_Circ2d()
+  : radius  (RealLast())
+  {}
 
-  //! The location point of XAxis is the center of the circle.
+  //! The location point of theXAxis is the center of the circle.
   //! Warnings :
-  //! It is not forbidden to create a circle with Radius = 0.0   Raises ConstructionError if Radius < 0.0.
-  //! Raised if Radius < 0.0.
-    gp_Circ2d(const gp_Ax2d& XAxis, const Standard_Real Radius, const Standard_Boolean Sense = Standard_True);
-  
-
-  //! Axis defines the Xaxis and Yaxis of the circle which defines
+  //! It is not forbidden to create a circle with theRadius = 0.0   Raises ConstructionError if theRadius < 0.0.
+  //! Raised if theRadius < 0.0.
+  gp_Circ2d (const gp_Ax2d& theXAxis, const Standard_Real theRadius, const Standard_Boolean theIsSense = Standard_True)
+  : radius (theRadius)
+  {
+    Standard_ConstructionError_Raise_if (theRadius < 0.0, "gp_Circ2d() - radius should be positive number");
+    pos = gp_Ax22d (theXAxis, theIsSense);
+  }
+
+  //! theAxis defines the Xaxis and Yaxis of the circle which defines
   //! the origin and the sense of parametrization.
-  //! The location point of Axis is the center of the circle.
+  //! The location point of theAxis is the center of the circle.
   //! Warnings :
-  //! It is not forbidden to create a circle with Radius = 0.0 Raises ConstructionError if Radius < 0.0.
-  //! Raised if Radius < 0.0.
-    gp_Circ2d(const gp_Ax22d& Axis, const Standard_Real Radius);
-  
+  //! It is not forbidden to create a circle with theRadius = 0.0 Raises ConstructionError if theRadius < 0.0.
+  //! Raised if theRadius < 0.0.
+  gp_Circ2d (const gp_Ax22d& theAxis, const Standard_Real theRadius)
+  : pos (theAxis),
+    radius (theRadius)
+  {
+    Standard_ConstructionError_Raise_if (theRadius < 0.0, "gp_Circ2d() - radius should be positive number");
+  }
+
   //! Changes the location point (center) of the circle.
-  void SetLocation (const gp_Pnt2d& P);
-  
+  void SetLocation (const gp_Pnt2d& theP) { pos.SetLocation (theP); }
+
   //! Changes the X axis of the circle.
-    void SetXAxis (const gp_Ax2d& A);
-  
+  void SetXAxis (const gp_Ax2d& theA) { pos.SetXAxis (theA); }
+
   //! Changes the X axis of the circle.
-    void SetAxis (const gp_Ax22d& A);
-  
+  void SetAxis (const gp_Ax22d& theA) { pos.SetAxis (theA); }
+
   //! Changes the Y axis of the circle.
-    void SetYAxis (const gp_Ax2d& A);
-  
+  void SetYAxis (const gp_Ax2d& theA) { pos.SetYAxis (theA); }
+
   //! Modifies the radius of this circle.
   //! This class does not prevent the creation of a circle where
-  //! Radius is null.
+  //! theRadius is null.
   //! Exceptions
-  //! Standard_ConstructionError if Radius is negative.
-    void SetRadius (const Standard_Real Radius);
-  
+  //! Standard_ConstructionError if theRadius is negative.
+  void SetRadius (const Standard_Real theRadius)
+  {
+    Standard_ConstructionError_Raise_if (theRadius < 0.0, "gp_Circ2d::SetRadius() - radius should be positive number");
+    radius = theRadius;
+  }
+
   //! Computes the area of the circle.
-    Standard_Real Area() const;
-  
+  Standard_Real Area() const { return M_PI * radius * radius; }
 
   //! Returns the normalized coefficients from the implicit equation
   //! of the circle :
-  //! A * (X**2) + B * (Y**2) + 2*C*(X*Y) + 2*D*X + 2*E*Y + F = 0.0
-    void Coefficients (Standard_Real& A, Standard_Real& B, Standard_Real& C, Standard_Real& D, Standard_Real& E, Standard_Real& F) const;
-  
-  //! Does <me> contain P ?
-  //! Returns True if the distance between P and any point on
+  //! theA * (X**2) + theB * (Y**2) + 2*theC*(X*Y) + 2*theD*X + 2*theE*Y + theF = 0.0
+  void Coefficients (Standard_Real& theA, Standard_Real& theB,
+                     Standard_Real& theC, Standard_Real& theD,
+                     Standard_Real& theE, Standard_Real& theF) const;
+
+  //! Does <me> contain theP ?
+  //! Returns True if the distance between theP and any point on
   //! the circumference of the circle is lower of equal to
-  //! <LinearTolerance>.
-    Standard_Boolean Contains (const gp_Pnt2d& P, const Standard_Real LinearTolerance) const;
-  
+  //! <theLinearTolerance>.
+  Standard_Boolean Contains (const gp_Pnt2d& theP, const Standard_Real theLinearTolerance) const
+  {
+    return Distance (theP) <= theLinearTolerance;
+  }
 
-  //! Computes the minimum of distance between the point P and any
+  //! Computes the minimum of distance between the point theP and any
   //! point on the circumference of the circle.
-    Standard_Real Distance (const gp_Pnt2d& P) const;
-  
+  Standard_Real Distance (const gp_Pnt2d& theP) const;
+
+  //! Computes the square distance between <me> and the point theP.
+  Standard_Real SquareDistance (const gp_Pnt2d& theP) const;
 
-  //! Computes the square distance between <me> and the point P.
-    Standard_Real SquareDistance (const gp_Pnt2d& P) const;
-  
   //! computes the circumference of the circle.
-    Standard_Real Length() const;
-  
+  Standard_Real Length() const { return 2. * M_PI * radius; }
+
   //! Returns the location point (center) of the circle.
-    const gp_Pnt2d& Location() const;
-  
+  const gp_Pnt2d& Location() const { return pos.Location(); }
+
   //! Returns the radius value of the circle.
-    Standard_Real Radius() const;
-  
+  Standard_Real Radius() const { return radius; }
+
   //! returns the position of the circle.
-    const gp_Ax22d& Axis() const;
-  
+  const gp_Ax22d& Axis() const { return pos; }
+
   //! returns the position of the circle. Idem Axis(me).
-    const gp_Ax22d& Position() const;
-  
+  const gp_Ax22d& Position() const { return pos; }
+
   //! returns the X axis of the circle.
-    gp_Ax2d XAxis() const;
-  
+  gp_Ax2d XAxis() const { return gp_Ax2d (pos.XAxis()); }
+
   //! Returns the Y axis of the circle.
   //! Reverses the direction of the circle.
-    gp_Ax2d YAxis() const;
-  
+  gp_Ax2d YAxis() const { return gp_Ax2d (pos.YAxis()); }
+
   //! Reverses the orientation of the local coordinate system
   //! of this circle (the "Y Direction" is reversed) and therefore
   //! changes the implicit orientation of this circle.
   //! Reverse assigns the result to this circle,
-    void Reverse();
-  
+  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 circle (the "Y Direction" is reversed) and therefore
   //! changes the implicit orientation of this circle.
   //! Reversed creates a new circle.
-    Standard_NODISCARD gp_Circ2d Reversed() const;
-  
+  Standard_NODISCARD gp_Circ2d 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 circle with respect
-  //! to the point P which is the center of the symmetry
-  Standard_NODISCARD Standard_EXPORT gp_Circ2d 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_Circ2d Mirrored (const gp_Pnt2d& theP) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2d& theA);
 
   //! Performs the symmetrical transformation of a circle with respect
   //! to an axis placement which is the axis of the symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Circ2d Mirrored (const gp_Ax2d& A) const;
-  
-    void Rotate (const gp_Pnt2d& P, const Standard_Real Ang);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Circ2d Mirrored (const gp_Ax2d& theA) const;
+
+  void Rotate (const gp_Pnt2d& theP, const Standard_Real theAng)
+  {
+    pos.Rotate (theP, theAng);
+  }
 
-  //! Rotates a circle. P is the center of the rotation.
+  //! Rotates a circle. theP is the center of the rotation.
   //! Ang is the angular value of the rotation in radians.
-    Standard_NODISCARD gp_Circ2d Rotated (const gp_Pnt2d& P, const Standard_Real Ang) const;
-  
-    void Scale (const gp_Pnt2d& P, const Standard_Real S);
-  
+  Standard_NODISCARD gp_Circ2d Rotated (const gp_Pnt2d& theP, const Standard_Real theAng) const
+  {
+    gp_Circ2d aCirc = *this;
+    aCirc.pos.Rotate (theP, theAng);
+    return aCirc;
+  }
+
+  void Scale (const gp_Pnt2d& theP, const Standard_Real theS);
 
-  //! Scales a circle. S is the scaling value.
+  //! Scales a circle. theS is the scaling value.
   //! Warnings :
-  //! If S is negative the radius stay positive but
+  //! If theS is negative the radius stay positive but
   //! the "XAxis" and the "YAxis" are  reversed as for
   //! an ellipse.
-    Standard_NODISCARD gp_Circ2d Scaled (const gp_Pnt2d& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf2d& T);
-  
-
-  //! Transforms a circle with the transformation T from class Trsf2d.
-    Standard_NODISCARD gp_Circ2d Transformed (const gp_Trsf2d& T) const;
-  
-    void Translate (const gp_Vec2d& V);
-  
-
-  //! Translates a circle in the direction of the vector V.
-  //! The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Circ2d Translated (const gp_Vec2d& V) const;
-  
-    void Translate (const gp_Pnt2d& P1, const gp_Pnt2d& P2);
-  
-
-  //! Translates a circle from the point P1 to the point P2.
-    Standard_NODISCARD gp_Circ2d Translated (const gp_Pnt2d& P1, const gp_Pnt2d& P2) const;
-
-
-
-
-protected:
+  Standard_NODISCARD gp_Circ2d Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const;
 
+  void Transform (const gp_Trsf2d& theT);
 
+  //! Transforms a circle with the transformation theT from class Trsf2d.
+  Standard_NODISCARD gp_Circ2d Transformed (const gp_Trsf2d& theT) const;
 
+  void Translate (const gp_Vec2d& theV) { pos.Translate (theV); }
 
+  //! Translates a circle in the direction of the vector theV.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Circ2d Translated (const gp_Vec2d& theV) const
+  {
+    gp_Circ2d aCirc = *this;
+    aCirc.pos.Translate (theV);
+    return aCirc;
+  }
+
+  void Translate (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) { pos.Translate (theP1, theP2); }
+
+  //! Translates a circle from the point theP1 to the point theP2.
+  Standard_NODISCARD gp_Circ2d Translated (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) const
+  {
+    gp_Circ2d aCirc = *this;
+    aCirc.pos.Translate (theP1, theP2);
+    return aCirc;
+  }
 
 private:
 
-
-
   gp_Ax22d pos;
   Standard_Real radius;
 
-
 };
 
-
-#include <gp_Circ2d.lxx>
-
-
-
-
+// =======================================================================
+// function : Coefficients
+// purpose  :
+// =======================================================================
+inline void gp_Circ2d::Coefficients (Standard_Real& theA,
+                                     Standard_Real& theB,
+                                     Standard_Real& theC,
+                                     Standard_Real& theD,
+                                     Standard_Real& theE,
+                                     Standard_Real& theF) const
+{
+  Standard_Real aXc = pos.Location().X();
+  Standard_Real anYc = pos.Location().Y();
+  theA = 1.0;
+  theB = 1.0;
+  theC = 0.0;
+  theD = - aXc;
+  theE = - anYc;
+  theF = aXc * aXc + anYc * anYc - radius * radius;
+}
+
+// =======================================================================
+// function : Distance
+// purpose  :
+// =======================================================================
+inline Standard_Real gp_Circ2d::Distance (const gp_Pnt2d& theP) const
+{
+  gp_XY aCoord = theP.XY();
+  aCoord.Subtract (pos.Location().XY());
+  Standard_Real aD = radius - aCoord.Modulus();
+  if (aD < 0)
+  {
+    aD = -aD;
+  }
+  return aD;
+}
+
+// =======================================================================
+// function : Reversed
+// purpose  :
+// =======================================================================
+inline gp_Circ2d gp_Circ2d::Reversed() const
+{
+  gp_Circ2d aCirc = *this;
+  gp_Dir2d aTemp = pos.YDirection();
+  aTemp.Reverse();
+  aCirc.pos.SetAxis (gp_Ax22d(pos.Location(), pos.XDirection(), aTemp));
+  return aCirc;
+}
+
+// =======================================================================
+// function : SquareDistance
+// purpose  :
+// =======================================================================
+inline Standard_Real gp_Circ2d::SquareDistance (const gp_Pnt2d& theP) const
+{
+  gp_XY aCoord = theP.XY();
+  aCoord.Subtract (pos.Location().XY());
+  Standard_Real aD = radius - aCoord.Modulus();
+  return aD * aD;
+}
+
+// =======================================================================
+// function : Scale
+// purpose  :
+// =======================================================================
+inline void gp_Circ2d::Scale (const gp_Pnt2d& theP, const Standard_Real theS)
+{
+  radius *= theS;
+  if (radius < 0)
+  {
+    radius = -radius;
+  }
+  pos.Scale (theP, theS);
+}
+
+// =======================================================================
+// function : Scaled
+// purpose  :
+// =======================================================================
+inline gp_Circ2d gp_Circ2d::Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const
+{
+  gp_Circ2d aCirc = *this;
+  aCirc.radius *= theS;
+  if (aCirc.radius < 0)
+  {
+    aCirc.radius = -aCirc.radius;
+  }
+  aCirc.pos.Scale (theP, theS);
+  return aCirc;
+}
+
+// =======================================================================
+// function : Transform
+// purpose  :
+// =======================================================================
+inline void gp_Circ2d::Transform (const gp_Trsf2d& theT)
+{
+  radius *= theT.ScaleFactor();
+  if (radius < 0)
+  {
+    radius = -radius;
+  }
+  pos.Transform (theT);
+}
+
+// =======================================================================
+// function : Transformed
+// purpose  :
+// =======================================================================
+inline gp_Circ2d gp_Circ2d::Transformed (const gp_Trsf2d& theT) const
+{
+  gp_Circ2d aCirc = *this;
+  aCirc.radius *= theT.ScaleFactor();
+  if (aCirc.radius < 0)
+  {
+    aCirc.radius = -aCirc.radius;
+  }
+  aCirc.pos.Transform (theT);
+  return aCirc;
+}
 
 #endif // _gp_Circ2d_HeaderFile
diff --git a/src/gp/gp_Circ2d.lxx b/src/gp/gp_Circ2d.lxx
deleted file mode 100644 (file)
index 40aa958..0000000
+++ /dev/null
@@ -1,203 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_ConstructionError.hxx>
-
-inline gp_Circ2d::gp_Circ2d () : radius(RealLast())
-{ }
-
-inline gp_Circ2d::gp_Circ2d (const gp_Ax2d& XAxis, 
-                            const Standard_Real Radius,
-                            const Standard_Boolean Sense) : radius(Radius)
-{
-  Standard_ConstructionError_Raise_if (Radius < 0.0, "gp_Circ2d() - radius should be positive number");
-  pos = gp_Ax22d(XAxis,Sense);
-}
-
-inline gp_Circ2d::gp_Circ2d (const gp_Ax22d&     Axis, 
-                            const Standard_Real Radius) :
-                            pos(Axis),
-                            radius(Radius)
-{
-  Standard_ConstructionError_Raise_if (Radius < 0.0, "gp_Circ2d() - radius should be positive number");
-}
-
-inline void gp_Circ2d::SetLocation (const gp_Pnt2d& P)
-{ pos.SetLocation (P); }
-
-inline void gp_Circ2d::SetXAxis (const gp_Ax2d& A)
-{  pos.SetXAxis(A); }
-
-inline void gp_Circ2d::SetAxis (const gp_Ax22d& A)
-{  pos.SetAxis(A);}
-
-inline void gp_Circ2d::SetYAxis (const gp_Ax2d& A)
-{   pos.SetYAxis(A); }
-
-inline void gp_Circ2d::SetRadius (const Standard_Real Radius)
-{ 
-  Standard_ConstructionError_Raise_if (Radius < 0.0, "gp_Circ2d::SetRadius() - radius should be positive number");
-  radius = Radius;
-}
-
-inline   Standard_Real gp_Circ2d::Area() const
-{ return M_PI * radius * radius; }
-
-inline void gp_Circ2d::Coefficients (Standard_Real& A,
-                                    Standard_Real& B,
-                                    Standard_Real& C,
-                                    Standard_Real& D,
-                                    Standard_Real& E,
-                                    Standard_Real& F) const
-{
-  Standard_Real Xc = pos.Location().X();
-  Standard_Real Yc = pos.Location().Y();
-  A = 1.0;
-  B = 1.0;
-  C = 0.0;
-  D = - Xc;
-  E = - Yc;
-  F = Xc * Xc + Yc * Yc - radius * radius;
-}
-
-inline Standard_Boolean gp_Circ2d::Contains
-(const gp_Pnt2d& P,
- const Standard_Real LinearTolerance) const
-{ return Distance(P) <= LinearTolerance; }
-
-inline Standard_Real gp_Circ2d::Distance (const gp_Pnt2d& P) const
-{
-  gp_XY Coord = P.XY();
-  Coord.Subtract (pos.Location().XY());
-  Standard_Real D = radius - Coord.Modulus();
-  if (D < 0) D = - D;
-  return D;
-}
-
-inline Standard_Real gp_Circ2d::SquareDistance (const gp_Pnt2d& P) const
-{
-  gp_XY Coord = P.XY();
-  Coord.Subtract (pos.Location().XY());        
-  Standard_Real D = radius - Coord.Modulus();
-  return D * D;
-}
-
-inline   Standard_Real gp_Circ2d::Length() const
-{ return 2. * M_PI * radius; }
-
-inline const gp_Pnt2d& gp_Circ2d::Location () const
-{return pos.Location(); }
-
-inline   Standard_Real gp_Circ2d::Radius() const
-{ return radius; }
-
-inline   const gp_Ax22d& gp_Circ2d::Axis () const
-{ return pos; }
-
-inline   const gp_Ax22d& gp_Circ2d::Position () const
-{ return pos; }
-
-inline gp_Ax2d gp_Circ2d::XAxis () const
-{ return gp_Ax2d (pos.XAxis()); }
-
-inline gp_Ax2d gp_Circ2d::YAxis () const
-{ return gp_Ax2d (pos.YAxis()); }
-
-inline void gp_Circ2d::Reverse() 
-{
-  gp_Dir2d Temp = pos.YDirection ();
-  Temp.Reverse ();
-  pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
-}
-
-inline gp_Circ2d gp_Circ2d::Reversed() const
-{
-  gp_Circ2d C = *this;
-  gp_Dir2d Temp = pos.YDirection ();
-  Temp.Reverse ();
-  C.pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
-  return C;
-}
-
-inline Standard_Boolean gp_Circ2d::IsDirect() const
-{ return (pos.XDirection().Crossed(pos.YDirection())) >= 0.0; }
-
-inline void gp_Circ2d::Rotate (const gp_Pnt2d& P,
-                              const Standard_Real Ang)
-{pos.Rotate (P, Ang);}
-
-inline gp_Circ2d gp_Circ2d::Rotated (const gp_Pnt2d& P,
-                                    const Standard_Real Ang) const
-{
-  gp_Circ2d C = *this;
-  C.pos.Rotate (P, Ang);
-  return C; 
-}
-
-inline void gp_Circ2d::Scale (const gp_Pnt2d& P,
-                             const Standard_Real S)
-{ 
-  radius *= S;
-  if (radius < 0) radius = - radius;
-  pos.Scale(P, S);
-}
-
-inline gp_Circ2d gp_Circ2d::Scaled (const gp_Pnt2d& P,
-                                   const Standard_Real S) const
-{
-  gp_Circ2d C = *this;
-  C.radius *= S;
-  if (C.radius < 0) C.radius = - C.radius;
-  C.pos.Scale(P, S);
-  return C; 
-}
-
-inline void gp_Circ2d::Transform (const gp_Trsf2d& T)
-{
-  radius *= T.ScaleFactor();
-  if (radius < 0) radius = - radius;
-  pos.Transform(T);
-}
-
-inline gp_Circ2d gp_Circ2d::Transformed (const gp_Trsf2d& T) const
-{
-  gp_Circ2d C = *this;
-  C.radius *= T.ScaleFactor();
-  if (C.radius < 0) C.radius = - C.radius;
-  C.pos.Transform(T);
-  return C;
-}
-
-inline void gp_Circ2d::Translate (const gp_Vec2d& V)
-{ pos.Translate(V); }
-
-inline gp_Circ2d gp_Circ2d::Translated (const gp_Vec2d& V) const
-{
-  gp_Circ2d C = *this;
-  C.pos.Translate(V);
-  return C; 
-}
-
-inline void gp_Circ2d::Translate (const gp_Pnt2d& P1,
-                                 const gp_Pnt2d& P2)
-{ pos.Translate(P1, P2); }
-
-inline gp_Circ2d gp_Circ2d::Translated (const gp_Pnt2d& P1,
-                                       const gp_Pnt2d& P2) const
-{
-  gp_Circ2d C = *this;
-  C.pos.Translate(P1, P2);
-  return C; 
-}
-
index 34b595f..a213943 100644 (file)
 // LPA, JCV  07/92 passage sur C1.
 // JCV 07/92 Introduction de la method Dump 
 
+#include <gp_Cone.hxx>
+
 #include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
 #include <gp_Ax3.hxx>
-#include <gp_Cone.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Trsf.hxx>
 #include <gp_Vec.hxx>
index 4110bae..94ab6ed 100644 (file)
 #ifndef _gp_Cone_HeaderFile
 #define _gp_Cone_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
+#include <gp_Ax1.hxx>
 #include <gp_Ax3.hxx>
-#include <Standard_Real.hxx>
 #include <gp_Pnt.hxx>
-#include <Standard_Boolean.hxx>
-#include <gp_Ax1.hxx>
-class Standard_ConstructionError;
-class gp_Ax3;
-class gp_Ax1;
-class gp_Pnt;
-class gp_Ax2;
-class gp_Trsf;
-class gp_Vec;
-
-
 
 //! Defines an infinite conical surface.
 //! A cone is defined by its half-angle (can be negative) at the apex and
@@ -69,176 +54,272 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an indefinite Cone.
-    gp_Cone();
-  
+  gp_Cone()
+  : radius (RealLast()),
+    semiAngle (M_PI * 0.25)
+  {}
 
-  //! Creates an infinite conical surface. A3 locates the cone
+  //! Creates an infinite conical surface. theA3 locates the cone
   //! in the space and defines the reference plane of the surface.
   //! Ang is the conical surface semi-angle. Its absolute value is in range
   //! ]0, PI/2[.
-  //! Radius is the radius of the circle in the reference plane of
+  //! theRadius is the radius of the circle in the reference plane of
   //! the cone.
-  //! Raises ConstructionError
-  //! * if Radius is lower than 0.0
-  //! * Abs(Ang) < Resolution from gp  or Abs(Ang) >= (PI/2) - Resolution.
-    gp_Cone(const gp_Ax3& A3, const Standard_Real Ang, const Standard_Real Radius);
-  
+  //! theRaises ConstructionError
+  //! * if theRadius is lower than 0.0
+  //! * Abs(theAng) < Resolution from gp  or Abs(theAng) >= (PI/2) - Resolution.
+  gp_Cone (const gp_Ax3& theA3, const Standard_Real theAng, const Standard_Real theRadius);
+
   //! Changes the symmetry axis of the cone.  Raises ConstructionError
-  //! the direction of A1 is parallel to the "XDirection"
+  //! the direction of theA1 is parallel to the "XDirection"
   //! of the coordinate system of the cone.
-    void SetAxis (const gp_Ax1& A1);
-  
+  void SetAxis (const gp_Ax1& theA1) { pos.SetAxis (theA1); }
+
   //! Changes the location of the cone.
-    void SetLocation (const gp_Pnt& Loc);
-  
+  void SetLocation (const gp_Pnt& theLoc) { pos.SetLocation (theLoc); }
 
   //! Changes the local coordinate system of the cone.
   //! This coordinate system defines the reference plane of the cone.
-    void SetPosition (const gp_Ax3& A3);
-  
+  void SetPosition (const gp_Ax3& theA3) { pos = theA3; }
 
   //! Changes the radius of the cone in the reference plane of
   //! the cone.
-  //! Raised if R < 0.0
-    void SetRadius (const Standard_Real R);
-  
+  //! Raised if theR < 0.0
+  void SetRadius (const Standard_Real theR)
+  {
+    Standard_ConstructionError_Raise_if (theR < 0.0, "gp_Cone::SetRadius() - radius should be positive number");
+    radius = theR;
+  }
 
   //! Changes the semi-angle of the cone.
   //! Semi-angle can be negative. Its absolute value
-  //! Abs(Ang) is in range ]0,PI/2[.
-  //! Raises ConstructionError if Abs(Ang) < Resolution from gp or Abs(Ang) >= PI/2 - Resolution
-    void SetSemiAngle (const Standard_Real Ang);
-  
+  //! Abs(theAng) is in range ]0,PI/2[.
+  //! Raises ConstructionError if Abs(theAng) < Resolution from gp or Abs(theAng) >= PI/2 - Resolution
+  void SetSemiAngle (const Standard_Real theAng);
 
   //! Computes the cone's top. The Apex of the cone is on the
   //! negative side of the symmetry axis of the cone.
-    gp_Pnt Apex() const;
-  
+  gp_Pnt Apex() const
+  {
+    gp_XYZ aCoord = pos.Direction().XYZ();
+    aCoord.Multiply (-radius / Tan (semiAngle));
+    aCoord.Add (pos.Location().XYZ());
+    return gp_Pnt (aCoord);
+  }
+
   //! Reverses the   U   parametrization of   the  cone
   //! reversing the YAxis.
-    void UReverse();
-  
+  void UReverse() { pos.YReverse(); }
+
   //! Reverses the   V   parametrization of   the  cone  reversing the ZAxis.
-    void VReverse();
-  
+  void VReverse()
+  {
+    pos.ZReverse();
+    semiAngle = -semiAngle;
+  }
+
   //! Returns true if the local coordinate system of this cone is right-handed.
-    Standard_Boolean Direct() const;
-  
+  Standard_Boolean Direct() const { return pos.Direct(); }
+
   //! returns the symmetry axis of the cone.
-    const gp_Ax1& Axis() const;
-  
+  const gp_Ax1& Axis() const { return pos.Axis(); }
 
   //! Computes the coefficients of the implicit equation of the quadric
   //! in the absolute cartesian coordinates system :
-  //! A1.X**2 + A2.Y**2 + A3.Z**2 + 2.(B1.X.Y + B2.X.Z + B3.Y.Z) +
-  //! 2.(C1.X + C2.Y + C3.Z) + D = 0.0
-  Standard_EXPORT void Coefficients (Standard_Real& A1, Standard_Real& A2, Standard_Real& A3, Standard_Real& B1, Standard_Real& B2, Standard_Real& B3, Standard_Real& C1, Standard_Real& C2, Standard_Real& C3, Standard_Real& D) const;
-  
+  //! theA1.X**2 + theA2.Y**2 + theA3.Z**2 + 2.(theB1.X.Y + theB2.X.Z + theB3.Y.Z) +
+  //! 2.(theC1.X + theC2.Y + theC3.Z) + theD = 0.0
+  Standard_EXPORT void Coefficients (Standard_Real& theA1, Standard_Real& theA2, Standard_Real& theA3,
+                                     Standard_Real& theB1, Standard_Real& theB2, Standard_Real& theB3,
+                                     Standard_Real& theC1, Standard_Real& theC2, Standard_Real& theC3, Standard_Real& theD) const;
+
   //! returns the "Location" point of the cone.
-    const gp_Pnt& Location() const;
-  
+  const gp_Pnt& Location() const { return pos.Location(); }
 
   //! Returns the local coordinates system of the cone.
-    const gp_Ax3& Position() const;
-  
+  const gp_Ax3& Position() const { return pos; }
 
   //! Returns the radius of the cone in the reference plane.
-    Standard_Real RefRadius() const;
-  
+  Standard_Real RefRadius() const { return radius; }
+
   //! Returns the half-angle at the apex of this cone.
   //! Attention! Semi-angle can be negative.
-    Standard_Real SemiAngle() const;
-  
+  Standard_Real SemiAngle() const { return semiAngle; }
+
   //! Returns the XAxis of the reference plane.
-    gp_Ax1 XAxis() const;
-  
+  gp_Ax1 XAxis() const  { return gp_Ax1 (pos.Location(), pos.XDirection()); }
+
   //! Returns the YAxis of the reference plane.
-    gp_Ax1 YAxis() const;
-  
-  Standard_EXPORT void Mirror (const gp_Pnt& P);
-  
+  gp_Ax1 YAxis() const  { return gp_Ax1 (pos.Location(), pos.YDirection()); }
+
+  Standard_EXPORT void Mirror (const gp_Pnt& theP);
 
   //! Performs the symmetrical transformation of a cone
-  //! with respect to the point P which is the center of the
+  //! with respect to the point theP which is the center of the
   //! symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Cone Mirrored (const gp_Pnt& P) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax1& A1);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Cone Mirrored (const gp_Pnt& theP) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax1& theA1);
 
   //! Performs the symmetrical transformation of a cone with
   //! respect to an axis placement which is the axis of the
   //! symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Cone Mirrored (const gp_Ax1& A1) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2& A2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Cone Mirrored (const gp_Ax1& theA1) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2& theA2);
 
   //! Performs the symmetrical transformation of a cone with respect
-  //! to a plane. The axis placement A2 locates the plane of the
+  //! to a plane. The axis placement theA2 locates the plane of the
   //! of the symmetry : (Location, XDirection, YDirection).
-  Standard_NODISCARD Standard_EXPORT gp_Cone Mirrored (const gp_Ax2& A2) const;
-  
-    void Rotate (const gp_Ax1& A1, const Standard_Real Ang);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Cone Mirrored (const gp_Ax2& theA2) const;
 
-  //! Rotates a cone. A1 is the axis of the rotation.
-  //! Ang is the angular value of the rotation in radians.
-    Standard_NODISCARD gp_Cone Rotated (const gp_Ax1& A1, const Standard_Real Ang) const;
-  
-    void Scale (const gp_Pnt& P, const Standard_Real S);
-  
-
-  //! Scales a cone. S is the scaling value.
-  //! The absolute value of S is used to scale the cone
-    Standard_NODISCARD gp_Cone Scaled (const gp_Pnt& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf& T);
-  
-
-  //! Transforms a cone with the transformation T from class Trsf.
-    Standard_NODISCARD gp_Cone Transformed (const gp_Trsf& T) const;
-  
-    void Translate (const gp_Vec& V);
-  
-
-  //! Translates a cone in the direction of the vector V.
-  //! The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Cone Translated (const gp_Vec& V) const;
-  
-    void Translate (const gp_Pnt& P1, const gp_Pnt& P2);
-  
+  void Rotate (const gp_Ax1& theA1, const Standard_Real theAng)  { pos.Rotate (theA1, theAng); }
 
-  //! Translates a cone from the point P1 to the point P2.
-    Standard_NODISCARD gp_Cone Translated (const gp_Pnt& P1, const gp_Pnt& P2) const;
+  //! Rotates a cone. theA1 is the axis of the rotation.
+  //! Ang is the angular value of the rotation in radians.
+  Standard_NODISCARD gp_Cone Rotated (const gp_Ax1& theA1, const Standard_Real theAng) const
+  {
+    gp_Cone aCone = *this;
+    aCone.pos.Rotate (theA1, theAng);
+    return aCone;
+  }
 
+  void Scale (const gp_Pnt& theP, const Standard_Real theS);
 
+  //! Scales a cone. theS is the scaling value.
+  //! The absolute value of theS is used to scale the cone
+  Standard_NODISCARD gp_Cone Scaled (const gp_Pnt& theP, const Standard_Real theS) const;
 
+  void Transform (const gp_Trsf& theT);
 
-protected:
+  //! Transforms a cone with the transformation theT from class Trsf.
+  Standard_NODISCARD gp_Cone Transformed (const gp_Trsf& theT) const;
 
+  void Translate (const gp_Vec& theV) { pos.Translate (theV); }
 
+  //! Translates a cone in the direction of the vector theV.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Cone Translated (const gp_Vec& theV) const
+  {
+    gp_Cone aCone = *this;
+    aCone.pos.Translate (theV);
+    return aCone;
+  }
 
+  void Translate (const gp_Pnt& theP1, const gp_Pnt& theP2)  { pos.Translate (theP1, theP2); }
 
+  //! Translates a cone from the point P1 to the point P2.
+  Standard_NODISCARD gp_Cone Translated (const gp_Pnt& theP1, const gp_Pnt& theP2) const
+  {
+    gp_Cone aCone = *this;
+    aCone.pos.Translate (theP1, theP2);
+    return aCone;
+  }
 
 private:
 
-
-
   gp_Ax3 pos;
   Standard_Real radius;
   Standard_Real semiAngle;
 
-
 };
 
-
-#include <gp_Cone.lxx>
-
-
-
-
+// =======================================================================
+// function : gp_Cone
+// purpose  :
+// =======================================================================
+inline gp_Cone::gp_Cone (const gp_Ax3& theA3,
+                         const Standard_Real theAng,
+                         const Standard_Real theRadius)
+: pos (theA3),
+  radius (theRadius),
+  semiAngle (theAng)
+{
+  Standard_Real aVal = theAng;
+  if (aVal < 0)
+  {
+    aVal = -aVal;
+  }
+  Standard_ConstructionError_Raise_if (theRadius < 0. || aVal <= gp::Resolution() || M_PI * 0.5 - aVal <= gp::Resolution(),
+                                       "gp_Cone() - invalid construction parameters");
+}
+
+// =======================================================================
+// function : SetSemiAngle
+// purpose  :
+// =======================================================================
+inline void gp_Cone::SetSemiAngle (const Standard_Real theAng)
+{
+  Standard_Real aVal = theAng;
+  if (aVal < 0)
+  {
+    aVal = -aVal;
+  }
+  Standard_ConstructionError_Raise_if (aVal <= gp::Resolution() || M_PI * 0.5 - aVal <= gp::Resolution(),
+                                       "gp_Cone::SetSemiAngle() - invalid angle range");
+  semiAngle = theAng;
+}
+
+// =======================================================================
+// function : Scale
+// purpose  :
+// =======================================================================
+inline void gp_Cone::Scale (const gp_Pnt& theP,
+                            const Standard_Real theS)
+{
+  pos.Scale (theP, theS);
+  radius *= theS;
+  if (radius < 0)
+  {
+    radius = -radius;
+  }
+}
+
+// =======================================================================
+// function : Scaled
+// purpose  :
+// =======================================================================
+inline gp_Cone gp_Cone::Scaled (const gp_Pnt& theP,
+                                const Standard_Real theS) const
+{
+  gp_Cone aC = *this;
+  aC.pos.Scale (theP, theS);
+  aC.radius *= theS;
+  if (aC.radius < 0)
+  {
+    aC.radius = -aC.radius;
+  }
+  return aC;
+}
+
+// =======================================================================
+// function : Transform
+// purpose  :
+// =======================================================================
+inline void gp_Cone::Transform (const gp_Trsf& theT)
+{
+  pos.Transform (theT);
+  radius *= theT.ScaleFactor();
+  if (radius < 0)
+  {
+    radius = -radius;
+  }
+}
+
+// =======================================================================
+// function : Transformed
+// purpose  :
+// =======================================================================
+inline gp_Cone gp_Cone::Transformed (const gp_Trsf& theT) const
+{
+  gp_Cone aC = *this;
+  aC.pos.Transform (theT);
+  aC.radius *= theT.ScaleFactor();
+  if (aC.radius < 0)
+  {
+    aC.radius = -aC.radius;
+  }
+  return aC;
+}
 
 #endif // _gp_Cone_HeaderFile
diff --git a/src/gp/gp_Cone.lxx b/src/gp/gp_Cone.lxx
deleted file mode 100644 (file)
index 3a73a72..0000000
+++ /dev/null
@@ -1,168 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp.hxx>
-#include <Standard_ConstructionError.hxx>
-
-inline gp_Cone::gp_Cone () :
-radius (RealLast()),
-semiAngle (M_PI * 0.25)
-{ }
-
-inline gp_Cone::gp_Cone (const gp_Ax3& A3,
-                        const Standard_Real Ang,
-                        const Standard_Real Radius) :
-                        pos(A3),
-                        radius (Radius),
-                        semiAngle (Ang)
-{
-  Standard_Real val = Ang;
-  if (val < 0) val = - val;
-  Standard_ConstructionError_Raise_if
-    (radius < 0. ||
-     val            <= gp::Resolution() ||
-     M_PI * 0.5 - val <= gp::Resolution(), "gp_Cone() - invalid construction parameters");
-}
-
-inline void gp_Cone::SetAxis     (const gp_Ax1& A1)
-{ pos.SetAxis (A1); }
-
-inline void gp_Cone::SetLocation (const gp_Pnt& Loc)
-{ pos.SetLocation (Loc); }
-
-inline void gp_Cone::SetPosition (const gp_Ax3& A3)
-{ pos = A3; }
-
-inline void gp_Cone::SetRadius (const Standard_Real R)
-{
-  Standard_ConstructionError_Raise_if (R < 0.0, "gp_Cone::SetRadius() - radius should be positive number");
-  radius = R;
-}
-
-inline void gp_Cone::SetSemiAngle (const Standard_Real Ang)
-{
-  Standard_Real val = Ang;
-  if (val < 0) val = - val;
-  Standard_ConstructionError_Raise_if
-    (val            <= gp::Resolution() ||
-     M_PI * 0.5 - val <= gp::Resolution(), "gp_Cone::SetSemiAngle() - invalid angle range");
-  semiAngle = Ang;
-}
-
-inline gp_Pnt gp_Cone::Apex () const
-{
-  gp_XYZ Coord = pos.Direction ().XYZ ();
-  Coord.Multiply (-radius / Tan (semiAngle));
-  Coord.Add (pos.Location ().XYZ());
-  return gp_Pnt (Coord);
-}
-
-inline void gp_Cone::UReverse()
-{ pos.YReverse(); }
-
-inline void gp_Cone::VReverse()
-{ pos.ZReverse(); semiAngle = -semiAngle; }
-
-inline Standard_Boolean gp_Cone::Direct() const
-{ return pos.Direct(); }
-
-inline const gp_Ax1& gp_Cone::Axis () const
-{ return pos.Axis(); }
-
-inline const gp_Pnt& gp_Cone::Location () const
-{ return pos.Location(); }
-
-inline const gp_Ax3& gp_Cone::Position () const
-{ return pos; }
-
-inline Standard_Real gp_Cone::RefRadius () const
-{ return radius; }
-
-inline Standard_Real gp_Cone::SemiAngle () const
-{ return semiAngle; }
-
-inline gp_Ax1 gp_Cone::XAxis () const
-{ return gp_Ax1 (pos.Location(), pos.XDirection()); }
-
-inline gp_Ax1 gp_Cone::YAxis () const
-{ return gp_Ax1 (pos.Location(), pos.YDirection()); }
-
-inline void gp_Cone::Rotate (const gp_Ax1& A1,
-                            const Standard_Real Ang)
-{pos.Rotate (A1, Ang);}
-
-inline gp_Cone gp_Cone::Rotated (const gp_Ax1& A1,
-                                const Standard_Real Ang) const
-{
-  gp_Cone C = *this;
-  C.pos.Rotate (A1, Ang);
-  return C;
-}
-
-inline void gp_Cone::Scale (const gp_Pnt& P,
-                           const Standard_Real S)
-{
-  pos.Scale (P, S);      
-  radius *= S;
-  if (radius < 0) radius = - radius;
-}
-
-inline gp_Cone gp_Cone::Scaled (const gp_Pnt& P,
-                               const Standard_Real S) const
-{
-  gp_Cone C = *this;
-  C.pos.Scale (P, S);
-  C.radius *= S;
-  if (C.radius < 0) C.radius = - C.radius;
-  return C;
-}
-
-inline void gp_Cone::Transform (const gp_Trsf& T)
-{
-  pos.Transform (T);
-  radius *= T.ScaleFactor();
-  if (radius < 0) radius = - radius;
-}
-
-inline gp_Cone gp_Cone::Transformed (const gp_Trsf& T) const
-{
-  gp_Cone C = *this;
-  C.pos.Transform (T);
-  C.radius *= T.ScaleFactor();
-  if (C.radius < 0) C.radius = - C.radius;
-  return C;
-}
-
-inline void gp_Cone::Translate (const gp_Vec& V)
-{ pos.Translate (V); }
-
-inline gp_Cone gp_Cone::Translated (const gp_Vec& V) const
-{
-  gp_Cone C = *this;
-  C.pos.Translate (V);
-  return C;
-}
-
-inline void gp_Cone::Translate (const gp_Pnt& P1,
-                               const gp_Pnt& P2)
-{ pos.Translate (P1, P2); }
-
-inline gp_Cone gp_Cone::Translated (const gp_Pnt& P1,
-                                   const gp_Pnt& P2) const
-{
-  gp_Cone C = *this;
-  C.pos.Translate (P1, P2);
-  return C;
-}
-
index ac15a57..2511c7f 100644 (file)
 // JCV 07/92 Introduction de la method Dump 
 // LBO 08/93 passage aux Ax3
 
+#include <gp_Cylinder.hxx>
+
 #include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
 #include <gp_Ax3.hxx>
-#include <gp_Cylinder.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Trsf.hxx>
 #include <gp_Vec.hxx>
index fb5aaed..3cf992b 100644 (file)
 #ifndef _gp_Cylinder_HeaderFile
 #define _gp_Cylinder_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <gp_Ax3.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Boolean.hxx>
 #include <gp_Ax1.hxx>
-class Standard_ConstructionError;
-class gp_Ax3;
-class gp_Ax1;
-class gp_Pnt;
-class gp_Ax2;
-class gp_Trsf;
-class gp_Vec;
-
-
+#include <gp_Ax3.hxx>
 
 //! Describes an infinite cylindrical surface.
 //! A cylinder is defined by its radius and positioned in space
@@ -59,147 +44,203 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates a indefinite cylinder.
-    gp_Cylinder();
-  
+  gp_Cylinder() { radius = RealLast(); }
+
   //! Creates a cylinder of radius Radius, whose axis is the "main
-  //! Axis" of A3. A3 is the local coordinate system of the cylinder.   Raises ConstructionErrord if R < 0.0
-    gp_Cylinder(const gp_Ax3& A3, const Standard_Real Radius);
-  
-  //! Changes the symmetry axis of the cylinder. Raises ConstructionError if the direction of A1 is parallel to the "XDirection"
+  //! Axis" of theA3. theA3 is the local coordinate system of the cylinder.   Raises ConstructionErrord if theRadius < 0.0
+  gp_Cylinder (const gp_Ax3& theA3, const Standard_Real theRadius)
+  : pos (theA3),
+    radius (theRadius)
+  {
+    Standard_ConstructionError_Raise_if (theRadius < 0.0, "gp_Cylinder() - radius should be positive number");
+  }
+
+  //! Changes the symmetry axis of the cylinder. Raises ConstructionError if the direction of theA1 is parallel to the "XDirection"
   //! of the coordinate system of the cylinder.
-    void SetAxis (const gp_Ax1& A1);
-  
+  void SetAxis (const gp_Ax1& theA1)  { pos.SetAxis (theA1); }
+
   //! Changes the location of the surface.
-    void SetLocation (const gp_Pnt& Loc);
-  
+  void SetLocation (const gp_Pnt& theLoc)  { pos.SetLocation (theLoc); }
+
   //! Change the local coordinate system of the surface.
-    void SetPosition (const gp_Ax3& A3);
-  
+  void SetPosition (const gp_Ax3& theA3) { pos = theA3; }
+
   //! Modifies the radius of this cylinder.
   //! Exceptions
-  //! Standard_ConstructionError if R is negative.
-    void SetRadius (const Standard_Real R);
-  
+  //! Standard_ConstructionError if theR is negative.
+  void SetRadius (const Standard_Real theR)
+  {
+    Standard_ConstructionError_Raise_if (theR < 0.0, "gp_Cylinder::SetRadius() - radius should be positive number");
+    radius = theR;
+  }
+
   //! Reverses the   U   parametrization of   the cylinder
   //! reversing the YAxis.
-    void UReverse();
-  
+  void UReverse() { pos.YReverse(); }
+
   //! Reverses the   V   parametrization of   the  plane
   //! reversing the Axis.
-    void VReverse();
-  
+  void VReverse() { pos.ZReverse(); }
+
   //! Returns true if the local coordinate system of this cylinder is right-handed.
-    Standard_Boolean Direct() const;
-  
+  Standard_Boolean Direct() const { return pos.Direct(); }
+
   //! Returns the symmetry axis of the cylinder.
-    const gp_Ax1& Axis() const;
-  
+  const gp_Ax1& Axis() const { return pos.Axis(); }
 
   //! Computes the coefficients of the implicit equation of the quadric
   //! in the absolute cartesian coordinate system :
-  //! A1.X**2 + A2.Y**2 + A3.Z**2 + 2.(B1.X.Y + B2.X.Z + B3.Y.Z) +
-  //! 2.(C1.X + C2.Y + C3.Z) + D = 0.0
-  Standard_EXPORT void Coefficients (Standard_Real& A1, Standard_Real& A2, Standard_Real& A3, Standard_Real& B1, Standard_Real& B2, Standard_Real& B3, Standard_Real& C1, Standard_Real& C2, Standard_Real& C3, Standard_Real& D) const;
-  
+  //! theA1.X**2 + theA2.Y**2 + theA3.Z**2 + 2.(theB1.X.Y + theB2.X.Z + theB3.Y.Z) +
+  //! 2.(theC1.X + theC2.Y + theC3.Z) + theD = 0.0
+  Standard_EXPORT void Coefficients (Standard_Real& theA1, Standard_Real& theA2, Standard_Real& theA3,
+                                     Standard_Real& theB1, Standard_Real& theB2, Standard_Real& theB3,
+                                     Standard_Real& theC1, Standard_Real& theC2, Standard_Real& theC3, Standard_Real& theD) const;
+
   //! Returns the "Location" point of the cylinder.
-    const gp_Pnt& Location() const;
-  
+  const gp_Pnt& Location() const { return pos.Location(); }
 
   //! Returns the local coordinate system of the cylinder.
-    const gp_Ax3& Position() const;
-  
+  const gp_Ax3& Position() const { return pos; }
+
   //! Returns the radius of the cylinder.
-    Standard_Real Radius() const;
-  
+  Standard_Real Radius() const { return radius; }
+
   //! Returns the axis X of the cylinder.
-    gp_Ax1 XAxis() const;
-  
+  gp_Ax1 XAxis() const { return gp_Ax1 (pos.Location(), pos.XDirection()); }
+
   //! Returns the axis Y of the cylinder.
-    gp_Ax1 YAxis() const;
-  
-  Standard_EXPORT void Mirror (const gp_Pnt& P);
-  
+  gp_Ax1 YAxis() const { return gp_Ax1 (pos.Location(), pos.YDirection()); }
+
+  Standard_EXPORT void Mirror (const gp_Pnt& theP);
 
   //! Performs the symmetrical transformation of a cylinder
-  //! with respect to the point P which is the center of the
+  //! with respect to the point theP which is the center of the
   //! symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Cylinder Mirrored (const gp_Pnt& P) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax1& A1);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Cylinder Mirrored (const gp_Pnt& theP) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax1& theA1);
 
   //! Performs the symmetrical transformation of a cylinder with
   //! respect to an axis placement which is the axis of the
   //! symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Cylinder Mirrored (const gp_Ax1& A1) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2& A2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Cylinder Mirrored (const gp_Ax1& theA1) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2& theA2);
 
   //! Performs the symmetrical transformation of a cylinder with respect
-  //! to a plane. The axis placement A2 locates the plane of the
+  //! to a plane. The axis placement theA2 locates the plane of the
   //! of the symmetry : (Location, XDirection, YDirection).
-  Standard_NODISCARD Standard_EXPORT gp_Cylinder Mirrored (const gp_Ax2& A2) const;
-  
-    void Rotate (const gp_Ax1& A1, const Standard_Real Ang);
-  
-
-  //! Rotates a cylinder. A1 is the axis of the rotation.
-  //! Ang is the angular value of the rotation in radians.
-    Standard_NODISCARD gp_Cylinder Rotated (const gp_Ax1& A1, const Standard_Real Ang) const;
-  
-    void Scale (const gp_Pnt& P, const Standard_Real S);
-  
-
-  //! Scales a cylinder. S is the scaling value.
-  //! The absolute value of S is used to scale the cylinder
-    Standard_NODISCARD gp_Cylinder Scaled (const gp_Pnt& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf& T);
-  
-
-  //! Transforms a cylinder with the transformation T from class Trsf.
-    Standard_NODISCARD gp_Cylinder Transformed (const gp_Trsf& T) const;
-  
-    void Translate (const gp_Vec& V);
-  
-
-  //! Translates a cylinder in the direction of the vector V.
-  //! The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Cylinder Translated (const gp_Vec& V) const;
-  
-    void Translate (const gp_Pnt& P1, const gp_Pnt& P2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Cylinder Mirrored (const gp_Ax2& theA2) const;
 
-  //! Translates a cylinder from the point P1 to the point P2.
-    Standard_NODISCARD gp_Cylinder Translated (const gp_Pnt& P1, const gp_Pnt& P2) const;
+  void Rotate (const gp_Ax1& theA1, const Standard_Real theAng)  { pos.Rotate (theA1, theAng); }
 
+  //! Rotates a cylinder. theA1 is the axis of the rotation.
+  //! theAng is the angular value of the rotation in radians.
+  Standard_NODISCARD gp_Cylinder Rotated (const gp_Ax1& theA1, const Standard_Real theAng) const
+  {
+    gp_Cylinder aCyl = *this;
+    aCyl.pos.Rotate (theA1, theAng);
+    return aCyl;
+  }
 
+  void Scale (const gp_Pnt& theP, const Standard_Real theS);
 
+  //! Scales a cylinder. theS is the scaling value.
+  //! The absolute value of theS is used to scale the cylinder
+  Standard_NODISCARD gp_Cylinder Scaled (const gp_Pnt& theP, const Standard_Real theS) const;
 
-protected:
-
+  void Transform (const gp_Trsf& theT);
 
+  //! Transforms a cylinder with the transformation theT from class Trsf.
+  Standard_NODISCARD gp_Cylinder Transformed (const gp_Trsf& theT) const;
 
+  void Translate (const gp_Vec& theV)  { pos.Translate (theV); }
 
+  //! Translates a cylinder in the direction of the vector theV.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Cylinder Translated (const gp_Vec& theV) const
+  {
+    gp_Cylinder aCyl = *this;
+    aCyl.pos.Translate (theV);
+    return aCyl;
+  }
+
+  void Translate (const gp_Pnt& theP1, const gp_Pnt& theP2)  { pos.Translate (theP1, theP2); }
+
+  //! Translates a cylinder from the point theP1 to the point theP2.
+  Standard_NODISCARD gp_Cylinder Translated (const gp_Pnt& theP1, const gp_Pnt& theP2) const
+  {
+    gp_Cylinder aCyl = *this;
+    aCyl.pos.Translate (theP1, theP2);
+    return aCyl;
+  }
 
 private:
 
-
-
   gp_Ax3 pos;
   Standard_Real radius;
 
-
 };
 
-
-#include <gp_Cylinder.lxx>
-
-
-
-
+// =======================================================================
+// function : Scale
+// purpose  :
+// =======================================================================
+inline void gp_Cylinder::Scale (const gp_Pnt& theP, const Standard_Real theS)
+{
+  pos.Scale (theP, theS);
+  radius *= theS;
+  if (radius < 0)
+  {
+    radius = -radius;
+  }
+}
+
+// =======================================================================
+// function : Scaled
+// purpose  :
+// =======================================================================
+inline gp_Cylinder gp_Cylinder::Scaled (const gp_Pnt& theP, const Standard_Real theS) const
+{
+  gp_Cylinder aCyl = *this;
+  aCyl.pos.Scale (theP, theS);
+  aCyl.radius *= theS;
+  if (aCyl.radius < 0)
+  {
+    aCyl.radius = -aCyl.radius;
+  }
+  return aCyl;
+}
+
+// =======================================================================
+// function : Transform
+// purpose  :
+// =======================================================================
+inline void gp_Cylinder::Transform (const gp_Trsf& theT)
+{
+  pos.Transform (theT);
+  radius *= theT.ScaleFactor();
+  if (radius < 0)
+  {
+    radius = -radius;
+  }
+}
+
+// =======================================================================
+// function : Transformed
+// purpose  :
+// =======================================================================
+inline gp_Cylinder gp_Cylinder::Transformed (const gp_Trsf& theT) const
+{
+  gp_Cylinder aCyl = *this;
+  aCyl.pos.Transform (theT);
+  aCyl.radius *= theT.ScaleFactor();
+  if (aCyl.radius < 0)
+  {
+    aCyl.radius = -aCyl.radius;
+  }
+  return aCyl;
+}
 
 #endif // _gp_Cylinder_HeaderFile
diff --git a/src/gp/gp_Cylinder.lxx b/src/gp/gp_Cylinder.lxx
deleted file mode 100644 (file)
index 6201bbf..0000000
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_ConstructionError.hxx>
-
-inline gp_Cylinder::gp_Cylinder ()
-{ radius = RealLast(); }
-
-inline gp_Cylinder::gp_Cylinder (const gp_Ax3& A3,
-                                const Standard_Real Radius) :
-                                pos(A3),
-                                radius (Radius)
-{
-  Standard_ConstructionError_Raise_if (Radius < 0.0, "gp_Cylinder() - radius should be positive number");
-}
-
-inline void gp_Cylinder::SetAxis (const gp_Ax1& A1)
-{ pos.SetAxis (A1); }
-
-inline void gp_Cylinder::SetLocation (const gp_Pnt& Loc)
-{ pos.SetLocation (Loc); }
-
-inline void gp_Cylinder::SetPosition (const gp_Ax3& A3)
-{ pos = A3; }
-
-inline void gp_Cylinder::SetRadius (const Standard_Real R)
-{
-  Standard_ConstructionError_Raise_if (R < 0.0, "gp_Cylinder::SetRadius() - radius should be positive number");
-  radius = R;
-}
-
-inline void gp_Cylinder::UReverse()
-{ pos.YReverse(); }
-
-inline void gp_Cylinder::VReverse()
-{ pos.ZReverse(); }
-
-inline Standard_Boolean gp_Cylinder::Direct() const
-{ return pos.Direct(); }
-
-inline const gp_Ax1&  gp_Cylinder::Axis () const
-{ return pos.Axis(); }
-
-inline const gp_Pnt&  gp_Cylinder::Location () const
-{ return pos.Location(); }
-
-inline const gp_Ax3&  gp_Cylinder::Position () const
-{ return pos; }
-
-inline Standard_Real gp_Cylinder::Radius () const
-{ return radius; }
-
-inline gp_Ax1 gp_Cylinder::XAxis () const
-{return gp_Ax1(pos.Location(), pos.XDirection());}
-
-inline gp_Ax1 gp_Cylinder::YAxis () const
-{return gp_Ax1(pos.Location(), pos.YDirection());}
-
-inline void gp_Cylinder::Rotate (const gp_Ax1& A1,
-                                const Standard_Real Ang)
-{pos.Rotate(A1,Ang);}
-
-inline gp_Cylinder gp_Cylinder::Rotated (const gp_Ax1& A1,
-                                        const Standard_Real Ang) const
-{
-  gp_Cylinder C = *this;
-  C.pos.Rotate (A1, Ang);
-  return C;
-}
-
-inline void gp_Cylinder::Scale (const gp_Pnt& P, const Standard_Real S)
-{
-  pos.Scale (P, S);      
-  radius *= S;
-  if (radius < 0) radius = - radius;
-}
-
-inline gp_Cylinder gp_Cylinder::Scaled (const gp_Pnt& P,
-                                       const Standard_Real S) const
-{
-  gp_Cylinder C = *this;
-  C.pos.Scale (P, S);
-  C.radius *= S;
-  if (C.radius < 0) C.radius = - C.radius;
-  return C;
-}
-
-inline void gp_Cylinder::Transform (const gp_Trsf& T)
-{
-  pos.Transform (T);
-  radius *= T.ScaleFactor();
-  if (radius < 0) radius = - radius;
-}
-
-inline gp_Cylinder gp_Cylinder::Transformed (const gp_Trsf& T) const
-{
-  gp_Cylinder C = *this;
-  C.pos.Transform (T);
-  C.radius *= T.ScaleFactor();
-  if (C.radius < 0) C.radius = - C.radius;
-  return C;
-}
-
-inline void gp_Cylinder::Translate (const gp_Vec& V)
-{ pos.Translate (V); }
-
-inline gp_Cylinder gp_Cylinder::Translated (const gp_Vec& V) const
-{
-  gp_Cylinder C = *this;
-  C.pos.Translate (V);
-  return C;
-}
-
-inline void gp_Cylinder::Translate (const gp_Pnt& P1,
-                                   const gp_Pnt& P2)
-{ pos.Translate (P1, P2); }
-
-inline gp_Cylinder gp_Cylinder::Translated (const gp_Pnt& P1,
-                                           const gp_Pnt& P2) const
-{
-  gp_Cylinder C = *this;
-  C.pos.Translate (P1, P2);
-  return C;
-}
-
index 3dfb999..1f18618 100644 (file)
 
 // JCV 07/12/90 Modifs suite a l'introduction des classes XYZ et Mat dans gp
 
+#include <gp_Dir.hxx>
+
 #include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
-#include <gp_Dir.hxx>
 #include <gp_Trsf.hxx>
 #include <gp_Vec.hxx>
 #include <gp_XYZ.hxx>
index a6215b2..37b6e7b 100644 (file)
 #ifndef _gp_Dir_HeaderFile
 #define _gp_Dir_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
 #include <gp_XYZ.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
-#include <Standard_Boolean.hxx>
-class Standard_ConstructionError;
-class Standard_DomainError;
-class Standard_OutOfRange;
+#include <Standard_ConstructionError.hxx>
+#include <Standard_DomainError.hxx>
+#include <Standard_OutOfRange.hxx>
+
 class gp_Vec;
-class gp_XYZ;
 class gp_Ax1;
 class gp_Ax2;
 class gp_Trsf;
 
-
-
 //! Describes a unit vector in 3D space. This unit vector is also called "Direction".
 //! See Also
 //! gce_MakeDir which provides functions for more complex
@@ -47,221 +38,235 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates a direction corresponding to X axis.
-    gp_Dir();
-  
-  //! Normalizes the vector V and creates a direction. Raises ConstructionError if V.Magnitude() <= Resolution.
-    gp_Dir(const gp_Vec& V);
-  
-  //! Creates a direction from a triplet of coordinates. Raises ConstructionError if Coord.Modulus() <= Resolution from gp.
-    gp_Dir(const gp_XYZ& Coord);
-  
-  //! Creates a direction with its 3 cartesian coordinates. Raises ConstructionError if Sqrt(Xv*Xv + Yv*Yv + Zv*Zv) <= Resolution
+  gp_Dir()
+  : coord (1., 0., 0.)
+  {}
+
+  //! Normalizes the vector theV and creates a direction. Raises ConstructionError if theV.Magnitude() <= Resolution.
+  gp_Dir (const gp_Vec& theV);
+
+  //! Creates a direction from a triplet of coordinates. Raises ConstructionError if theCoord.Modulus() <= Resolution from gp.
+  gp_Dir (const gp_XYZ& theCoord);
+
+  //! Creates a direction with its 3 cartesian coordinates. Raises ConstructionError if Sqrt(theXv*theXv + theYv*theYv + theZv*theZv) <= Resolution
   //! Modification of the direction's coordinates
-  //! If Sqrt (X*X + Y*Y + Z*Z) <= Resolution from gp where
-  //! X, Y ,Z are the new coordinates it is not possible to
+  //! If Sqrt (theXv*theXv + theYv*theYv + theZv*theZv) <= Resolution from gp where
+  //! theXv, theYv ,theZv are the new coordinates it is not possible to
   //! construct the direction and the method raises the
   //! exception ConstructionError.
-    gp_Dir(const Standard_Real Xv, const Standard_Real Yv, const Standard_Real Zv);
-  
+  gp_Dir (const Standard_Real theXv, const Standard_Real theYv, const Standard_Real theZv);
 
   //! For this unit vector,  assigns the value Xi to:
-  //! -   the X coordinate if Index is 1, or
-  //! -   the Y coordinate if Index is 2, or
-  //! -   the Z coordinate if Index is 3,
+  //! -   the X coordinate if theIndex is 1, or
+  //! -   the Y coordinate if theIndex is 2, or
+  //! -   the Z coordinate if theIndex is 3,
   //! and then normalizes it.
   //! Warning
   //! Remember that all the coordinates of a unit vector are
   //! implicitly modified when any single one is changed directly.
   //! Exceptions
-  //! Standard_OutOfRange if Index is not 1, 2, or 3.
+  //! Standard_OutOfRange if theIndex is not 1, 2, or 3.
   //! Standard_ConstructionError if either of the following
   //! is less than or equal to gp::Resolution():
   //! -   Sqrt(Xv*Xv + Yv*Yv + Zv*Zv), or
   //! -   the modulus of the number triple formed by the new
-  //! value Xi and the two other coordinates of this vector
+  //! value theXi and the two other coordinates of this vector
   //! that were not directly modified.
-    void SetCoord (const Standard_Integer Index, const Standard_Real Xi);
-  
-  //! For this unit vector,  assigns the values Xv, Yv and Zv to its three coordinates.
+  void SetCoord (const Standard_Integer theIndex, const Standard_Real theXi);
+
+  //! For this unit vector,  assigns the values theXv, theYv and theZv to its three coordinates.
   //! Remember that all the coordinates of a unit vector are
   //! implicitly modified when any single one is changed directly.
-    void SetCoord (const Standard_Real Xv, const Standard_Real Yv, const Standard_Real Zv);
-  
+  void SetCoord (const Standard_Real theXv, const Standard_Real theYv, const Standard_Real theZv);
+
   //! Assigns the given value to the X coordinate of this   unit vector.
-    void SetX (const Standard_Real X);
-  
+  void SetX (const Standard_Real theX);
+
   //! Assigns the given value to the Y coordinate of this   unit vector.
-    void SetY (const Standard_Real Y);
-  
+  void SetY (const Standard_Real theY);
+
   //! Assigns the given value to the Z  coordinate of this   unit vector.
-    void SetZ (const Standard_Real Z);
-  
-  //! Assigns the three coordinates of Coord to this unit vector.
-    void SetXYZ (const gp_XYZ& Coord);
-  
-
-  //! Returns the coordinate of range Index :
-  //! Index = 1 => X is returned
-  //! Index = 2 => Y is returned
-  //! Index = 3 => Z is returned
+  void SetZ (const Standard_Real theZ);
+
+  //! Assigns the three coordinates of theCoord to this unit vector.
+  void SetXYZ (const gp_XYZ& theCoord);
+
+  //! Returns the coordinate of range theIndex :
+  //! theIndex = 1 => X is returned
+  //! Ithendex = 2 => Y is returned
+  //! theIndex = 3 => Z is returned
   //! Exceptions
-  //! Standard_OutOfRange if Index is not 1, 2, or 3.
-    Standard_Real Coord (const Standard_Integer Index) const;
-  
-  //! Returns for the  unit vector  its three coordinates Xv, Yv, and Zv.
-    void Coord (Standard_Real& Xv, Standard_Real& Yv, Standard_Real& Zv) const;
-  
+  //! Standard_OutOfRange if theIndex is not 1, 2, or 3.
+  Standard_Real Coord (const Standard_Integer theIndex) const  { return coord.Coord (theIndex); }
+
+  //! Returns for the  unit vector  its three coordinates theXv, theYv, and theZv.
+  void Coord (Standard_Real& theXv, Standard_Real& theYv, Standard_Real& theZv) const  { coord.Coord (theXv, theYv, theZv); }
+
   //! Returns the X coordinate for a  unit vector.
-    Standard_Real X() const;
-  
+  Standard_Real X() const { return coord.X(); }
+
   //! Returns the Y coordinate for a  unit vector.
-    Standard_Real Y() const;
-  
+  Standard_Real Y() const { return coord.Y(); }
+
   //! Returns the Z coordinate for a  unit vector.
-    Standard_Real Z() const;
-  
+  Standard_Real Z() const { return coord.Z(); }
+
   //! for this unit vector, returns  its three coordinates as a number triplea.
-    const gp_XYZ& XYZ() const;
-  
+  const gp_XYZ& XYZ() const { return coord; }
 
   //! Returns True if the angle between the two directions is
-  //! lower or equal to AngularTolerance.
-    Standard_Boolean IsEqual (const gp_Dir& Other, const Standard_Real AngularTolerance) const;
-  
-
-  //! Returns True if  the angle between this unit vector and the unit vector Other is equal to Pi/2 (normal).
-    Standard_Boolean IsNormal (const gp_Dir& Other, const Standard_Real AngularTolerance) const;
-  
-
-  //! Returns True if  the angle between this unit vector and the unit vector Other is equal to  Pi (opposite).
-    Standard_Boolean IsOpposite (const gp_Dir& Other, const Standard_Real AngularTolerance) const;
-  
+  //! lower or equal to theAngularTolerance.
+  Standard_Boolean IsEqual (const gp_Dir& theOther, const Standard_Real theAngularTolerance) const
+  {
+    return Angle (theOther) <= theAngularTolerance;
+  }
+
+  //! Returns True if  the angle between this unit vector and the unit vector theOther is equal to Pi/2 (normal).
+  Standard_Boolean IsNormal (const gp_Dir& theOther, const Standard_Real theAngularTolerance) const
+  {
+    Standard_Real anAng = M_PI / 2.0 - Angle (theOther);
+    if (anAng < 0)
+    {
+      anAng = -anAng;
+    }
+    return anAng <= theAngularTolerance;
+  }
+
+  //! Returns True if  the angle between this unit vector and the unit vector theOther is equal to  Pi (opposite).
+  Standard_Boolean IsOpposite (const gp_Dir& theOther, const Standard_Real theAngularTolerance) const
+  {
+    return M_PI - Angle (theOther) <= theAngularTolerance;
+  }
 
   //! Returns true if the angle between this unit vector and the
-  //! unit vector Other is equal to 0 or to Pi.
-  //! Note: the tolerance criterion is given by AngularTolerance.
-    Standard_Boolean IsParallel (const gp_Dir& Other, const Standard_Real AngularTolerance) const;
-  
+  //! unit vector theOther is equal to 0 or to Pi.
+  //! Note: the tolerance criterion is given by theAngularTolerance.
+  Standard_Boolean IsParallel (const gp_Dir& theOther, const Standard_Real theAngularTolerance) const
+  {
+    Standard_Real anAng = Angle (theOther);
+    return anAng <= theAngularTolerance || M_PI - anAng <= theAngularTolerance;
+  }
 
   //! Computes the angular value in radians between <me> and
-  //! <Other>. This value is always positive in 3D space.
+  //! <theOther>. This value is always positive in 3D space.
   //! Returns the angle in the range [0, PI]
-  Standard_EXPORT Standard_Real Angle (const gp_Dir& Other) const;
-  
+  Standard_EXPORT Standard_Real Angle (const gp_Dir& theOther) const;
 
-  //! Computes the angular value between <me> and <Other>.
-  //! <VRef> is the direction of reference normal to <me> and <Other>
+  //! Computes the angular value between <me> and <theOther>.
+  //! <theVRef> is the direction of reference normal to <me> and <theOther>
   //! and its orientation gives the positive sense of rotation.
-  //! If the cross product <me> ^ <Other> has the same orientation
-  //! as <VRef> the angular value is positive else negative.
-  //! Returns the angular value in the range -PI and PI (in radians). Raises  DomainError if <me> and <Other> are not parallel this exception is raised
-  //! when <VRef> is in the same plane as <me> and <Other>
+  //! If the cross product <me> ^ <theOther> has the same orientation
+  //! as <theVRef> the angular value is positive else negative.
+  //! Returns the angular value in the range -PI and PI (in radians). Raises  DomainError if <me> and <theOther> are not parallel this exception is raised
+  //! when <theVRef> is in the same plane as <me> and <theOther>
   //! The tolerance criterion is Resolution from package gp.
-  Standard_EXPORT Standard_Real AngleWithRef (const gp_Dir& Other, const gp_Dir& VRef) const;
-  
+  Standard_EXPORT Standard_Real AngleWithRef (const gp_Dir& theOther, const gp_Dir& theVRef) const;
+
   //! Computes the cross product between two directions
   //! Raises the exception ConstructionError if the two directions
   //! are parallel because the computed vector cannot be normalized
   //! to create a direction.
-    void Cross (const gp_Dir& Right);
-  void operator ^= (const gp_Dir& Right)
-{
-  Cross(Right);
-}
-  
+  void Cross (const gp_Dir& theRight);
+
+  void operator ^= (const gp_Dir& theRight) { Cross (theRight); }
+
   //! Computes the triple vector product.
   //! <me> ^ (V1 ^ V2)
   //! Raises the exception ConstructionError if V1 and V2 are parallel
   //! or <me> and (V1^V2) are parallel because the computed vector
   //! can't be normalized to create a direction.
-  Standard_NODISCARD gp_Dir Crossed (const gp_Dir& Right) const;
-  Standard_NODISCARD gp_Dir operator ^ (const gp_Dir& Right) const
-{
-  return Crossed(Right);
-}
-  
-    void CrossCross (const gp_Dir& V1, const gp_Dir& V2);
-  
-  //! Computes the double vector product this ^ (V1 ^ V2).
+  Standard_NODISCARD gp_Dir Crossed (const gp_Dir& theRight) const;
+
+  Standard_NODISCARD gp_Dir operator ^ (const gp_Dir& theRight) const { return Crossed (theRight); }
+
+  void CrossCross (const gp_Dir& theV1, const gp_Dir& theV2);
+
+  //! Computes the double vector product this ^ (theV1 ^ theV2).
   //! -   CrossCrossed creates a new unit vector.
   //! Exceptions
   //! Standard_ConstructionError if:
-  //! -   V1 and V2 are parallel, or
-  //! -   this unit vector and (V1 ^ V2) are parallel.
+  //! -   theV1 and theV2 are parallel, or
+  //! -   this unit vector and (theV1 ^ theV2) are parallel.
   //! This is because, in these conditions, the computed vector
   //! is null and cannot be normalized.
-    Standard_NODISCARD gp_Dir CrossCrossed (const gp_Dir& V1, const gp_Dir& V2) const;
-  
+  Standard_NODISCARD gp_Dir CrossCrossed (const gp_Dir& theV1, const gp_Dir& theV2) const;
+
   //! Computes the scalar product
-    Standard_Real Dot (const gp_Dir& Other) const;
-  Standard_Real operator * (const gp_Dir& Other) const
-{
-  return Dot(Other);
-}
-  
+  Standard_Real Dot (const gp_Dir& theOther) const { return coord.Dot (theOther.coord); }
 
-  //! Computes the triple scalar product <me> * (V1 ^ V2).
+  Standard_Real operator * (const gp_Dir& theOther) const { return Dot (theOther); }
+
+  //! Computes the triple scalar product <me> * (theV1 ^ theV2).
   //! Warnings :
-  //! The computed vector V1' = V1 ^ V2 is not normalized
+  //! The computed vector theV1' = theV1 ^ theV2 is not normalized
   //! to create a unitary vector. So this method never
-  //! raises an exception even if V1 and V2 are parallel.
-    Standard_Real DotCross (const gp_Dir& V1, const gp_Dir& V2) const;
-  
-    void Reverse();
-  
+  //! raises an exception even if theV1 and theV2 are parallel.
+  Standard_Real DotCross (const gp_Dir& theV1, const gp_Dir& theV2) const
+  {
+    return coord.Dot (theV1.coord.Crossed (theV2.coord));
+  }
+
+  void Reverse() { coord.Reverse(); }
+
   //! Reverses the orientation of a direction
   //! geometric transformations
   //! Performs the symmetrical transformation of a direction
   //! with respect to the direction V which is the center of
   //! the  symmetry.]
-    Standard_NODISCARD gp_Dir Reversed() const;
-  Standard_NODISCARD gp_Dir operator -() const
-{
-  return Reversed();
-}
-  
-  Standard_EXPORT void Mirror (const gp_Dir& V);
-  
+  Standard_NODISCARD gp_Dir Reversed() const
+  {
+    gp_Dir aV = *this;
+    aV.coord.Reverse();
+    return aV;
+  }
+
+  Standard_NODISCARD gp_Dir operator -() const { return Reversed(); }
+
+  Standard_EXPORT void Mirror (const gp_Dir& theV);
 
   //! Performs the symmetrical transformation of a direction
-  //! with respect to the direction V which is the center of
+  //! with respect to the direction theV which is the center of
   //! the  symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Dir Mirrored (const gp_Dir& V) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax1& A1);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Dir Mirrored (const gp_Dir& theV) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax1& theA1);
 
   //! Performs the symmetrical transformation of a direction
   //! with respect to an axis placement which is the axis
   //! of the symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Dir Mirrored (const gp_Ax1& A1) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2& A2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Dir Mirrored (const gp_Ax1& theA1) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2& theA2);
 
   //! Performs the symmetrical transformation of a direction
-  //! with respect to a plane. The axis placement A2 locates
+  //! with respect to a plane. The axis placement theA2 locates
   //! the plane of the symmetry : (Location, XDirection, YDirection).
-  Standard_NODISCARD Standard_EXPORT gp_Dir Mirrored (const gp_Ax2& A2) const;
-  
-    void Rotate (const gp_Ax1& A1, const Standard_Real Ang);
-  
-
-  //! Rotates a direction. A1 is the axis of the rotation.
-  //! Ang is the angular value of the rotation in radians.
-    Standard_NODISCARD gp_Dir Rotated (const gp_Ax1& A1, const Standard_Real Ang) const;
-  
-  Standard_EXPORT void Transform (const gp_Trsf& T);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Dir Mirrored (const gp_Ax2& theA2) const;
+
+  void Rotate(const gp_Ax1& theA1, const Standard_Real theAng);
+
+  //! Rotates a direction. theA1 is the axis of the rotation.
+  //! theAng is the angular value of the rotation in radians.
+  Standard_NODISCARD gp_Dir Rotated (const gp_Ax1& theA1, const Standard_Real theAng) const
+  {
+    gp_Dir aV = *this;
+    aV.Rotate (theA1, theAng);
+    return aV;
+  }
+
+  Standard_EXPORT void Transform (const gp_Trsf& theT);
 
   //! Transforms a direction with a "Trsf" from gp.
   //! Warnings :
-  //! If the scale factor of the "Trsf" T is negative then the
+  //! If the scale factor of the "Trsf" theT is negative then the
   //! direction <me> is reversed.
-  Standard_NODISCARD gp_Dir Transformed (const gp_Trsf& T) const;
-
+  Standard_NODISCARD gp_Dir Transformed (const gp_Trsf& theT) const
+  {
+    gp_Dir aV = *this;
+    aV.Transform (theT);
+    return aV;
+  }
 
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
@@ -269,27 +274,228 @@ public:
   //! Inits the content of me from the stream
   Standard_EXPORT Standard_Boolean InitFromJson (const Standard_SStream& theSStream, Standard_Integer& theStreamPos);
 
+private:
 
-protected:
+  gp_XYZ coord;
 
+};
 
+#include <gp_Trsf.hxx>
 
+// =======================================================================
+// function : gp_Dir
+// purpose  :
+// =======================================================================
+inline gp_Dir::gp_Dir (const gp_Vec& theV)
+{
+  const gp_XYZ& aXYZ = theV.XYZ();
+  Standard_Real aX = aXYZ.X();
+  Standard_Real aY = aXYZ.Y();
+  Standard_Real aZ = aXYZ.Z();
+  Standard_Real aD = sqrt (aX * aX + aY * aY + aZ * aZ);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir() - input vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (aY / aD);
+  coord.SetZ (aZ / aD);
+}
 
+// =======================================================================
+// function : gp_Dir
+// purpose  :
+// =======================================================================
+inline gp_Dir::gp_Dir (const gp_XYZ& theXYZ)
+{
+  Standard_Real aX = theXYZ.X();
+  Standard_Real aY = theXYZ.Y();
+  Standard_Real aZ = theXYZ.Z();
+  Standard_Real aD = sqrt (aX * aX + aY * aY + aZ * aZ);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir() - input vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (aY / aD);
+  coord.SetZ (aZ / aD);
+}
 
-private:
+// =======================================================================
+// function : gp_Dir
+// purpose  :
+// =======================================================================
+inline gp_Dir::gp_Dir (const Standard_Real theXv,
+                       const Standard_Real theYv,
+                       const Standard_Real theZv)
+{
+  Standard_Real aD = sqrt (theXv * theXv + theYv * theYv + theZv * theZv);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir() - input vector has zero norm");
+  coord.SetX (theXv / aD);
+  coord.SetY (theYv / aD);
+  coord.SetZ (theZv / aD);
+}
 
+// =======================================================================
+// function : SetCoord
+// purpose  :
+// =======================================================================
+inline void gp_Dir::SetCoord (const Standard_Integer theIndex,
+                              const Standard_Real theXi)
+{
+  Standard_Real aX = coord.X();
+  Standard_Real aY = coord.Y();
+  Standard_Real aZ = coord.Z();
+  Standard_OutOfRange_Raise_if (theIndex < 1 || theIndex > 3, "gp_Dir::SetCoord() - index is out of range [1, 3]");
+  if (theIndex == 1)
+  {
+    aX = theXi;
+  }
+  else if (theIndex == 2)
+  {
+    aY = theXi;
+  }
+  else
+  {
+    aZ = theXi;
+  }
+  Standard_Real aD = sqrt (aX * aX + aY * aY + aZ * aZ);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::SetCoord() - result vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (aY / aD);
+  coord.SetZ (aZ / aD);
+}
 
+// =======================================================================
+// function : SetCoord
+// purpose  :
+// =======================================================================
+inline void gp_Dir::SetCoord (const Standard_Real theXv,
+                              const Standard_Real theYv,
+                              const Standard_Real theZv) {
+  Standard_Real aD = sqrt (theXv * theXv + theYv * theYv + theZv * theZv);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::SetCoord() - input vector has zero norm");
+  coord.SetX (theXv / aD);
+  coord.SetY (theYv / aD);
+  coord.SetZ (theZv / aD);
+}
 
-  gp_XYZ coord;
+// =======================================================================
+// function : SetX
+// purpose  :
+// =======================================================================
+inline void gp_Dir::SetX (const Standard_Real theX)
+{
+  Standard_Real anY = coord.Y();
+  Standard_Real aZ = coord.Z();
+  Standard_Real aD = sqrt (theX * theX + anY * anY + aZ * aZ);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::SetX() - result vector has zero norm");
+  coord.SetX (theX / aD);
+  coord.SetY (anY / aD);
+  coord.SetZ (aZ / aD);
+}
 
+// =======================================================================
+// function : SetY
+// purpose  :
+// =======================================================================
+inline void gp_Dir::SetY (const Standard_Real theY)
+{
+  Standard_Real aZ = coord.Z();
+  Standard_Real aX = coord.X();
+  Standard_Real aD = sqrt (aX * aX + theY * theY + aZ * aZ);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::SetY() - result vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (theY / aD);
+  coord.SetZ (aZ / aD);
+}
 
-};
+// =======================================================================
+// function : SetZ
+// purpose  :
+// =======================================================================
+inline void gp_Dir::SetZ (const Standard_Real theZ)
+{
+  Standard_Real aX = coord.X();
+  Standard_Real anY = coord.Y();
+  Standard_Real aD = sqrt (aX * aX + anY * anY + theZ * theZ);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::SetZ() - result vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (anY / aD);
+  coord.SetZ (theZ / aD);
+}
 
+// =======================================================================
+// function : SetXYZ
+// purpose  :
+// =======================================================================
+inline void gp_Dir::SetXYZ (const gp_XYZ& theXYZ)
+{
+  Standard_Real aX = theXYZ.X();
+  Standard_Real anY = theXYZ.Y();
+  Standard_Real aZ = theXYZ.Z();
+  Standard_Real aD = sqrt(aX * aX + anY * anY + aZ * aZ);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::SetX() - input vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (anY / aD);
+  coord.SetZ (aZ / aD);
+}
 
-#include <gp_Dir.lxx>
+// =======================================================================
+// function : Cross
+// purpose  :
+// =======================================================================
+inline void gp_Dir::Cross(const gp_Dir& theRight)
+{
+  coord.Cross (theRight.coord);
+  Standard_Real aD = coord.Modulus();
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::Cross() - result vector has zero norm");
+  coord.Divide (aD);
+}
 
+// =======================================================================
+// function : Crossed
+// purpose  :
+// =======================================================================
+inline gp_Dir gp_Dir::Crossed (const gp_Dir& theRight) const
+{
+  gp_Dir aV = *this;
+  aV.coord.Cross (theRight.coord);
+  Standard_Real aD = aV.coord.Modulus();
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::Crossed() - result vector has zero norm");
+  aV.coord.Divide (aD);
+  return aV;
+}
 
+// =======================================================================
+// function : CrossCross
+// purpose  :
+// =======================================================================
+inline void gp_Dir::CrossCross (const gp_Dir& theV1, const gp_Dir& theV2)
+{
+  coord.CrossCross (theV1.coord, theV2.coord);
+  Standard_Real aD = coord.Modulus();
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::CrossCross() - result vector has zero norm");
+  coord.Divide (aD);
+}
 
+// =======================================================================
+// function : CrossCrossed
+// purpose  :
+// =======================================================================
+inline gp_Dir gp_Dir::CrossCrossed (const gp_Dir& theV1, const gp_Dir& theV2) const
+{
+  gp_Dir aV = *this;
+  (aV.coord).CrossCross (theV1.coord, theV2.coord);
+  Standard_Real aD = aV.coord.Modulus();
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir::CrossCrossed() - result vector has zero norm");
+  aV.coord.Divide (aD);
+  return aV;
+}
 
+// =======================================================================
+// function : Rotate
+// purpose  :
+// =======================================================================
+inline void gp_Dir::Rotate(const gp_Ax1& theA1, const Standard_Real theAng)
+{
+  gp_Trsf aT;
+  aT.SetRotation (theA1, theAng);
+  coord.Multiply (aT.HVectorialPart());
+}
 
 #endif // _gp_Dir_HeaderFile
diff --git a/src/gp/gp_Dir.lxx b/src/gp/gp_Dir.lxx
deleted file mode 100644 (file)
index 98a5f8a..0000000
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp_Vec.hxx>
-#include <gp_Trsf.hxx>
-#include <Standard_ConstructionError.hxx>
-#include <Standard_OutOfRange.hxx>
-
-inline gp_Dir::gp_Dir () : coord(1.,0.,0.)
-{ 
-}
-
-inline gp_Dir::gp_Dir (const gp_Vec& V)
-{
-  const gp_XYZ& XYZ = V.XYZ();
-  Standard_Real X = XYZ.X();
-  Standard_Real Y = XYZ.Y();
-  Standard_Real Z = XYZ.Z();
-  Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir() - input vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-  coord.SetZ(Z / D);
-}
-
-inline gp_Dir::gp_Dir (const gp_XYZ& XYZ)
-{
-  Standard_Real X = XYZ.X();
-  Standard_Real Y = XYZ.Y();
-  Standard_Real Z = XYZ.Z();
-  Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir() - input vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-  coord.SetZ(Z / D);
-}
-
-inline gp_Dir::gp_Dir (const Standard_Real Xv,
-                      const Standard_Real Yv,
-                      const Standard_Real Zv)
-{
-  Standard_Real D = sqrt (Xv * Xv + Yv * Yv + Zv * Zv);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir() - input vector has zero norm");
-  coord.SetX(Xv / D);
-  coord.SetY(Yv / D);
-  coord.SetZ(Zv / D);
-}
-
-inline void gp_Dir::SetCoord (const Standard_Integer Index,
-                             const Standard_Real Xi)
-{
-  Standard_Real X = coord.X();
-  Standard_Real Y = coord.Y();
-  Standard_Real Z = coord.Z();
-  Standard_OutOfRange_Raise_if (Index < 1 || Index > 3, "gp_Dir::SetCoord() - index is out of range [1, 3]");
-  if      (Index == 1)  X = Xi;
-  else if (Index == 2)  Y = Xi;
-  else                  Z = Xi;
-  Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::SetCoord() - result vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-  coord.SetZ(Z / D);
-}
-
-inline void gp_Dir::SetCoord (const Standard_Real Xv,
-                             const Standard_Real Yv,
-                             const Standard_Real Zv) {
-  Standard_Real D = sqrt(Xv * Xv + Yv * Yv + Zv * Zv);
-  Standard_ConstructionError_Raise_if(D <= gp::Resolution(), "gp_Dir::SetCoord() - input vector has zero norm");
-  coord.SetX(Xv / D);
-  coord.SetY(Yv / D);
-  coord.SetZ(Zv / D);
-}
-
-inline void gp_Dir::SetX (const Standard_Real X)
-{
-  Standard_Real Y = coord.Y();
-  Standard_Real Z = coord.Z();
-  Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::SetX() - result vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-  coord.SetZ(Z / D);
-}
-
-inline void gp_Dir::SetY (const Standard_Real Y)
-{
-  Standard_Real Z = coord.Z();
-  Standard_Real X = coord.X();
-  Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::SetY() - result vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-  coord.SetZ(Z / D);
-}
-
-inline void gp_Dir::SetZ (const Standard_Real Z)
-{
-  Standard_Real X = coord.X();
-  Standard_Real Y = coord.Y();
-  Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::SetZ() - result vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-  coord.SetZ(Z / D);
-}
-
-inline void gp_Dir::SetXYZ (const gp_XYZ& XYZ)
-{
-  Standard_Real X = XYZ.X();
-  Standard_Real Y = XYZ.Y();
-  Standard_Real Z = XYZ.Z();
-  Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::SetX() - input vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-  coord.SetZ(Z / D);
-}
-
-inline Standard_Real gp_Dir::Coord (const Standard_Integer Index) const
-{ return coord.Coord (Index);}
-
-inline  void gp_Dir::Coord (Standard_Real& Xv,
-                           Standard_Real& Yv,
-                           Standard_Real& Zv) const
-{ coord.Coord (Xv, Yv, Zv); }
-
-inline  Standard_Real gp_Dir::X() const
-{ return coord.X() ; }
-
-inline  Standard_Real gp_Dir::Y() const
-{ return coord.Y() ; }
-
-inline  Standard_Real gp_Dir::Z() const
-{ return coord.Z() ; }
-
-inline  const gp_XYZ& gp_Dir::XYZ () const
-{ return coord; }
-
-inline Standard_Boolean gp_Dir::IsEqual
-(const gp_Dir& Other, 
- const Standard_Real AngularTolerance) const
-{ return   Angle (Other) <= AngularTolerance; }    
-
-inline Standard_Boolean gp_Dir::IsNormal
-(const gp_Dir& Other,
- const Standard_Real AngularTolerance) const
-{
-  Standard_Real Ang = M_PI / 2.0 - Angle (Other);
-  if (Ang < 0) Ang = - Ang;
-  return   Ang <= AngularTolerance;
-}    
-
-inline Standard_Boolean gp_Dir::IsOpposite
-(const gp_Dir& Other,
- const Standard_Real AngularTolerance) const
-{ return M_PI - Angle (Other) <= AngularTolerance; }    
-
-inline Standard_Boolean gp_Dir::IsParallel
-(const gp_Dir& Other, 
- const Standard_Real AngularTolerance) const
-{
-  Standard_Real Ang = Angle (Other);
-  return Ang <= AngularTolerance || M_PI - Ang <= AngularTolerance;
-}    
-
-inline void gp_Dir::Cross (const gp_Dir& Right)
-{ 
-  coord.Cross (Right.coord); 
-  Standard_Real D = coord.Modulus ();
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::Cross() - result vector has zero norm");
-  coord.Divide (D);
-}
-
-inline gp_Dir gp_Dir::Crossed (const gp_Dir& Right) const
-{
-  gp_Dir V = *this;
-  V.coord.Cross (Right.coord);
-  Standard_Real D = V.coord.Modulus();
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::Crossed() - result vector has zero norm");
-  V.coord.Divide (D);
-  return V;
-}
-
-inline void gp_Dir::CrossCross (const gp_Dir& V1,
-                               const gp_Dir& V2)
-{ 
-  coord.CrossCross (V1.coord, V2.coord);
-  Standard_Real D = coord.Modulus();
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::CrossCross() - result vector has zero norm");
-  coord.Divide(D);
-}
-
-inline gp_Dir gp_Dir::CrossCrossed (const gp_Dir& V1,
-                                   const gp_Dir& V2) const
-{
-  gp_Dir V = *this;
-  (V.coord).CrossCross (V1.coord, V2.coord);
-  Standard_Real D = V.coord.Modulus();
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir::CrossCrossed() - result vector has zero norm");
-  V.coord.Divide(D);
-  return V;
-}
-
-inline Standard_Real gp_Dir::Dot (const gp_Dir& Other) const
-{ return coord.Dot (Other.coord); }
-
-inline Standard_Real gp_Dir::DotCross (const gp_Dir& V1,
-                                      const gp_Dir& V2)  const
-{ return coord.Dot (V1.coord.Crossed (V2.coord)); } 
-
-inline void gp_Dir::Reverse ()
-{ coord.Reverse(); }
-
-inline gp_Dir gp_Dir::Reversed () const { 
-  gp_Dir V = *this;
-  V.coord.Reverse ();
-  return V;
-}
-
-inline void gp_Dir::Rotate (const gp_Ax1& A1, const Standard_Real Ang)
-{
-  gp_Trsf T;
-  T.SetRotation (A1, Ang);
-  coord.Multiply (T.HVectorialPart ());
-}
-
-inline gp_Dir gp_Dir::Rotated (const gp_Ax1& A1,
-                              const Standard_Real Ang) const
-{
-  gp_Dir V = *this;
-  V.Rotate (A1, Ang);
-  return V;
-}
-
-inline gp_Dir gp_Dir::Transformed (const gp_Trsf& T) const
-{
-  gp_Dir V = *this;
-  V.Transform (T);
-  return V;
-} 
-
index 57e7b46..6c3b481 100644 (file)
@@ -14,8 +14,9 @@
 
 // JCV 08/01/90 Modifs suite a l'introduction des classes XY et Mat2d dans gp
 
-#include <gp_Ax2d.hxx>
 #include <gp_Dir2d.hxx>
+
+#include <gp_Ax2d.hxx>
 #include <gp_Trsf2d.hxx>
 #include <gp_Vec2d.hxx>
 #include <gp_XY.hxx>
index 17fbde6..c14cff2 100644 (file)
 #ifndef _gp_Dir2d_HeaderFile
 #define _gp_Dir2d_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
 #include <gp_XY.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
-#include <Standard_Boolean.hxx>
-class Standard_ConstructionError;
-class Standard_DomainError;
-class Standard_OutOfRange;
+#include <Standard_ConstructionError.hxx>
+#include <Standard_DomainError.hxx>
+#include <Standard_OutOfRange.hxx>
+
 class gp_Vec2d;
 class gp_XY;
 class gp_Ax2d;
 class gp_Trsf2d;
 
-
 //! Describes a unit vector in the plane (2D space). This unit
 //! vector is also called "Direction".
 //! See Also
@@ -46,55 +39,53 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates a direction corresponding to X axis.
-    gp_Dir2d();
-  
-  //! Normalizes the vector V and creates a Direction. Raises ConstructionError if V.Magnitude() <= Resolution from gp.
-    gp_Dir2d(const gp_Vec2d& V);
-  
-  //! Creates a Direction from a doublet of coordinates. Raises ConstructionError if Coord.Modulus() <= Resolution from gp.
-    gp_Dir2d(const gp_XY& Coord);
-  
-  //! Creates a Direction with its 2 cartesian coordinates. Raises ConstructionError if Sqrt(Xv*Xv + Yv*Yv) <= Resolution from gp.
-    gp_Dir2d(const Standard_Real Xv, const Standard_Real Yv);
-  
+  gp_Dir2d()
+  : coord (1., 0.)
+  {}
+
+  //! Normalizes the vector theV and creates a Direction. Raises ConstructionError if theV.Magnitude() <= Resolution from gp.
+  gp_Dir2d (const gp_Vec2d& theV);
+
+  //! Creates a Direction from a doublet of coordinates. Raises ConstructionError if theCoord.Modulus() <= Resolution from gp.
+  gp_Dir2d (const gp_XY& theCoord);
+
+  //! Creates a Direction with its 2 cartesian coordinates. Raises ConstructionError if Sqrt(theXv*theXv + theYv*theYv) <= Resolution from gp.
+  gp_Dir2d (const Standard_Real theXv, const Standard_Real theYv);
 
   //! For this unit vector, assigns:
-  //! the value Xi to:
-  //! -   the X coordinate if Index is 1, or
-  //! -   the Y coordinate if Index is 2, and then normalizes it.
+  //! the value theXi to:
+  //! -   the X coordinate if theIndex is 1, or
+  //! -   the Y coordinate if theIndex is 2, and then normalizes it.
   //! Warning
   //! Remember that all the coordinates of a unit vector are
   //! implicitly modified when any single one is changed directly.
   //! Exceptions
-  //! Standard_OutOfRange if Index is not 1 or 2.
+  //! Standard_OutOfRange if theIndex is not 1 or 2.
   //! Standard_ConstructionError if either of the following
   //! is less than or equal to gp::Resolution():
-  //! -   Sqrt(Xv*Xv + Yv*Yv), or
+  //! -   Sqrt(theXv*theXv + theYv*theYv), or
   //! -   the modulus of the number pair formed by the new
-  //! value Xi and the other coordinate of this vector that
+  //! value theXi and the other coordinate of this vector that
   //! was not directly modified.
-  //! Raises OutOfRange if Index != {1, 2}.
-    void SetCoord (const Standard_Integer Index, const Standard_Real Xi);
-  
+  //! Raises OutOfRange if theIndex != {1, 2}.
+  void SetCoord (const Standard_Integer theIndex, const Standard_Real theXi);
 
   //! For this unit vector, assigns:
-  //! -   the values Xv and Yv to its two coordinates,
+  //! -   the values theXv and theYv to its two coordinates,
   //! Warning
   //! Remember that all the coordinates of a unit vector are
   //! implicitly modified when any single one is changed directly.
   //! Exceptions
-  //! Standard_OutOfRange if Index is not 1 or 2.
+  //! Standard_OutOfRange if theIndex is not 1 or 2.
   //! Standard_ConstructionError if either of the following
   //! is less than or equal to gp::Resolution():
-  //! -   Sqrt(Xv*Xv + Yv*Yv), or
+  //! -   Sqrt(theXv*theXv + theYv*theYv), or
   //! -   the modulus of the number pair formed by the new
   //! value Xi and the other coordinate of this vector that
   //! was not directly modified.
-  //! Raises OutOfRange if Index != {1, 2}.
-    void SetCoord (const Standard_Real Xv, const Standard_Real Yv);
-  
+  //! Raises OutOfRange if theIndex != {1, 2}.
+  void SetCoord (const Standard_Real theXv, const Standard_Real theYv);
 
   //! Assigns the given value to the X coordinate of this unit   vector,
   //! and then normalizes it.
@@ -108,8 +99,7 @@ public:
   //! -   the modulus of the number pair formed from the new
   //! X or Y coordinate and the other coordinate of this
   //! vector that was not directly modified.
-    void SetX (const Standard_Real X);
-  
+  void SetX (const Standard_Real theX);
 
   //! Assigns  the given value to the Y coordinate of this unit   vector,
   //! and then normalizes it.
@@ -123,11 +113,10 @@ public:
   //! -   the modulus of the number pair formed from the new
   //! X or Y coordinate and the other coordinate of this
   //! vector that was not directly modified.
-    void SetY (const Standard_Real Y);
-  
+  void SetY (const Standard_Real theY);
 
   //! Assigns:
-  //! -   the two coordinates of Coord to this unit vector,
+  //! -   the two coordinates of theCoord to this unit vector,
   //! and then normalizes it.
   //! Warning
   //! Remember that all the coordinates of a unit vector are
@@ -135,146 +124,323 @@ public:
   //! Exceptions
   //! Standard_ConstructionError if either of the following
   //! is less than or equal to gp::Resolution():
-  //! -   the modulus of Coord, or
+  //! -   the modulus of theCoord, or
   //! -   the modulus of the number pair formed from the new
   //! X or Y coordinate and the other coordinate of this
   //! vector that was not directly modified.
-    void SetXY (const gp_XY& Coord);
-  
-
-  //! For this unit vector returns the coordinate of range Index :
-  //! Index = 1 => X is returned
-  //! Index = 2 => Y is returned
-  //! Raises OutOfRange if Index != {1, 2}.
-    Standard_Real Coord (const Standard_Integer Index) const;
-  
-  //! For this unit vector returns its two coordinates Xv and Yv.
-  //! Raises OutOfRange if Index != {1, 2}.
-    void Coord (Standard_Real& Xv, Standard_Real& Yv) const;
-  
+  void SetXY (const gp_XY& theCoord);
+
+  //! For this unit vector returns the coordinate of range theIndex :
+  //! theIndex = 1 => X is returned
+  //! theIndex = 2 => Y is returned
+  //! Raises OutOfRange if theIndex != {1, 2}.
+  Standard_Real Coord (const Standard_Integer theIndex) const  { return coord.Coord (theIndex); }
+
+  //! For this unit vector returns its two coordinates theXv and theYv.
+  //! Raises OutOfRange if theIndex != {1, 2}.
+  void Coord (Standard_Real& theXv, Standard_Real& theYv) const  { coord.Coord (theXv, theYv); }
+
   //! For this unit vector, returns its X coordinate.
-    Standard_Real X() const;
-  
+  Standard_Real X() const { return coord.X(); }
+
   //! For this unit vector, returns its Y coordinate.
-    Standard_Real Y() const;
-  
+  Standard_Real Y() const { return coord.Y(); }
+
   //! For this unit vector, returns its two coordinates as a number pair.
   //! Comparison between Directions
   //! The precision value is an input data.
-    const gp_XY& XY() const;
-  
+  const gp_XY& XY() const { return coord; }
 
   //! Returns True if the two vectors have the same direction
   //! i.e. the angle between this unit vector and the
-  //! unit vector Other is less than or equal to AngularTolerance.
-    Standard_Boolean IsEqual (const gp_Dir2d& Other, const Standard_Real AngularTolerance) const;
-  
+  //! unit vector theOther is less than or equal to theAngularTolerance.
+  Standard_Boolean IsEqual (const gp_Dir2d& theOther, const Standard_Real theAngularTolerance) const;
 
   //! Returns True if the angle between this unit vector and the
-  //! unit vector Other is equal to Pi/2 or -Pi/2 (normal)
-  //! i.e. Abs(Abs(<me>.Angle(Other)) - PI/2.) <= AngularTolerance
-    Standard_Boolean IsNormal (const gp_Dir2d& Other, const Standard_Real AngularTolerance) const;
-  
+  //! unit vector theOther is equal to Pi/2 or -Pi/2 (normal)
+  //! i.e. Abs(Abs(<me>.Angle(theOther)) - PI/2.) <= theAngularTolerance
+  Standard_Boolean IsNormal (const gp_Dir2d& theOther, const Standard_Real theAngularTolerance) const;
 
   //! Returns True if the angle between this unit vector and the
-  //! unit vector Other is equal to Pi or -Pi (opposite).
-  //! i.e.  PI - Abs(<me>.Angle(Other)) <= AngularTolerance
-    Standard_Boolean IsOpposite (const gp_Dir2d& Other, const Standard_Real AngularTolerance) const;
-  
+  //! unit vector theOther is equal to Pi or -Pi (opposite).
+  //! i.e.  PI - Abs(<me>.Angle(theOther)) <= theAngularTolerance
+  Standard_Boolean IsOpposite (const gp_Dir2d& theOther, const Standard_Real theAngularTolerance) const;
 
   //! returns true if the angle between this unit vector and unit
-  //! vector Other is equal to 0, Pi or -Pi.
-  //! i.e.  Abs(Angle(<me>, Other)) <= AngularTolerance or
-  //! PI - Abs(Angle(<me>, Other)) <= AngularTolerance
-    Standard_Boolean IsParallel (const gp_Dir2d& Other, const Standard_Real AngularTolerance) const;
-  
+  //! vector theOther is equal to 0, Pi or -Pi.
+  //! i.e.  Abs(Angle(<me>, theOther)) <= theAngularTolerance or
+  //! PI - Abs(Angle(<me>, theOther)) <= theAngularTolerance
+  Standard_Boolean IsParallel (const gp_Dir2d& theOther, const Standard_Real theAngularTolerance) const;
 
   //! Computes the angular value in radians between <me> and
-  //! <Other>. Returns the angle in the range [-PI, PI].
-  Standard_EXPORT Standard_Real Angle (const gp_Dir2d& Other) const;
-  
+  //! <theOther>. Returns the angle in the range [-PI, PI].
+  Standard_EXPORT Standard_Real Angle (const gp_Dir2d& theOther) const;
 
   //! Computes the cross product between two directions.
-  Standard_NODISCARD Standard_Real Crossed (const gp_Dir2d& Right) const;
-  Standard_NODISCARD Standard_Real operator ^ (const gp_Dir2d& Right) const
-{
-  return Crossed(Right);
-}
-  
+  Standard_NODISCARD Standard_Real Crossed (const gp_Dir2d& theRight) const { return coord.Crossed (theRight.coord); }
+
+  Standard_NODISCARD Standard_Real operator ^ (const gp_Dir2d& theRight) const { return Crossed (theRight); }
+
   //! Computes the scalar product
-    Standard_Real Dot (const gp_Dir2d& Other) const;
-  Standard_Real operator * (const gp_Dir2d& Other) const
-{
-  return Dot(Other);
-}
-  
-    void Reverse();
-  
+  Standard_Real Dot (const gp_Dir2d& theOther) const { return coord.Dot (theOther.coord); }
+
+  Standard_Real operator * (const gp_Dir2d& theOther) const { return Dot (theOther); }
+
+  void Reverse() { coord.Reverse(); }
+
   //! Reverses the orientation of a direction
-    Standard_NODISCARD gp_Dir2d Reversed() const;
-  Standard_NODISCARD gp_Dir2d operator -() const
-{
-  return Reversed();
-}
-  
-  Standard_EXPORT void Mirror (const gp_Dir2d& V);
-  
+  Standard_NODISCARD gp_Dir2d Reversed() const
+  {
+    gp_Dir2d aV = *this;
+    aV.coord.Reverse();
+    return aV;
+  }
+
+  Standard_NODISCARD gp_Dir2d operator -() const { return Reversed(); }
+
+  Standard_EXPORT void Mirror (const gp_Dir2d& theV);
 
   //! Performs the symmetrical transformation of a direction
-  //! with respect to the direction V which is the center of
+  //! with respect to the direction theV which is the center of
   //! the  symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Dir2d Mirrored (const gp_Dir2d& V) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2d& A);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Dir2d Mirrored (const gp_Dir2d& theV) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2d& theA);
 
   //! Performs the symmetrical transformation of a direction
   //! with respect to an axis placement which is the axis
   //! of the symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Dir2d Mirrored (const gp_Ax2d& A) const;
-  
-    void Rotate (const Standard_Real Ang);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Dir2d Mirrored (const gp_Ax2d& theA) const;
+
+  void Rotate (const Standard_Real Ang);
 
-  //! Rotates a direction.  Ang is the angular value of
+  //! Rotates a direction.  theAng is the angular value of
   //! the rotation in radians.
-    Standard_NODISCARD gp_Dir2d Rotated (const Standard_Real Ang) const;
-  
-  Standard_EXPORT void Transform (const gp_Trsf2d& T);
-  
+  Standard_NODISCARD gp_Dir2d Rotated (const Standard_Real theAng) const
+  {
+    gp_Dir2d aV = *this;
+    aV.Rotate (theAng);
+    return aV;
+  }
 
-  //! Transforms a direction with the "Trsf" T.
+  Standard_EXPORT void Transform (const gp_Trsf2d& theT);
+
+  //! Transforms a direction with the "Trsf" theT.
   //! Warnings :
-  //! If the scale factor of the "Trsf" T is negative then the
+  //! If the scale factor of the "Trsf" theT is negative then the
   //! direction <me> is reversed.
-  Standard_NODISCARD gp_Dir2d Transformed (const gp_Trsf2d& T) const;
+  Standard_NODISCARD gp_Dir2d Transformed (const gp_Trsf2d& theT) const
+  {
+    gp_Dir2d aV = *this;
+    aV.Transform (theT);
+    return aV;
+  }
 
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
 
+private:
 
+  gp_XY coord;
 
+};
 
-protected:
-
-
-
+#include <gp_Ax2d.hxx>
+#include <gp_Trsf2d.hxx>
 
+// =======================================================================
+// function : gp_Dir2d
+// purpose  :
+// =======================================================================
+inline gp_Dir2d::gp_Dir2d (const gp_Vec2d& theV)
+{
+  const gp_XY& aXY = theV.XY();
+  Standard_Real aX = aXY.X();
+  Standard_Real anY = aXY.Y();
+  Standard_Real aD = sqrt (aX * aX + anY * anY);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir2d() - input vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (anY / aD);
+}
 
-private:
+// =======================================================================
+// function : gp_Dir2d
+// purpose  :
+// =======================================================================
+inline gp_Dir2d::gp_Dir2d (const gp_XY& theXY)
+{
+  Standard_Real aX = theXY.X();
+  Standard_Real anY = theXY.Y();
+  Standard_Real aD = sqrt (aX * aX + anY * anY);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir2d() - input vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (anY / aD);
+}
 
+// =======================================================================
+// function : gp_Dir2d
+// purpose  :
+// =======================================================================
+inline gp_Dir2d::gp_Dir2d (const Standard_Real theXv,
+                           const Standard_Real theYv)
+{
+  Standard_Real aD = sqrt (theXv * theXv + theYv * theYv);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir2d() - input vector has zero norm");
+  coord.SetX (theXv / aD);
+  coord.SetY (theYv / aD);
+}
 
+// =======================================================================
+// function : SetCoord
+// purpose  :
+// =======================================================================
+inline void gp_Dir2d::SetCoord (const Standard_Integer theIndex,
+                                const Standard_Real theXi)
+{
+  Standard_Real aX = coord.X();
+  Standard_Real anY = coord.Y();
+  Standard_OutOfRange_Raise_if (theIndex < 1 || theIndex > 2, "gp_Dir2d::SetCoord() - index is out of range [1, 2]");
+  if (theIndex == 1)
+  {
+    aX = theXi;
+  }
+  else
+  {
+    anY = theXi;
+  }
+  Standard_Real aD = sqrt (aX * aX + anY * anY);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir2d::SetCoord() - result vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (anY / aD);
+}
 
-  gp_XY coord;
+// =======================================================================
+// function : SetCoord
+// purpose  :
+// =======================================================================
+inline void gp_Dir2d::SetCoord (const Standard_Real theXv,
+                                const Standard_Real theYv)
+{
+  Standard_Real aD = sqrt (theXv * theXv + theYv * theYv);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir2d::SetCoord() - result vector has zero norm");
+  coord.SetX (theXv / aD);
+  coord.SetY (theYv / aD);
+}
 
+// =======================================================================
+// function : SetX
+// purpose  :
+// =======================================================================
+inline void gp_Dir2d::SetX (const Standard_Real theX)
+{
+  Standard_Real anY = coord.Y();
+  Standard_Real aD = sqrt (theX * theX + anY * anY);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir2d::SetX() - result vector has zero norm");
+  coord.SetX (theX / aD);
+  coord.SetY (anY / aD);
+}
 
-};
+// =======================================================================
+// function : SetY
+// purpose  :
+// =======================================================================
+inline void gp_Dir2d::SetY (const Standard_Real theY)
+{
+  Standard_Real aX = coord.X();
+  Standard_Real aD = sqrt (aX * aX + theY * theY);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir2d::SetY() - result vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (theY / aD);
+}
 
+// =======================================================================
+// function : SetXY
+// purpose  :
+// =======================================================================
+inline void gp_Dir2d::SetXY (const gp_XY& theXY)
+{
+  Standard_Real aX = theXY.X();
+  Standard_Real anY = theXY.Y();
+  Standard_Real aD = sqrt (aX * aX + anY * anY);
+  Standard_ConstructionError_Raise_if (aD <= gp::Resolution(), "gp_Dir2d::SetZ() - result vector has zero norm");
+  coord.SetX (aX / aD);
+  coord.SetY (anY / aD);
+}
 
-#include <gp_Dir2d.lxx>
+// =======================================================================
+// function : IsEqual
+// purpose  :
+// =======================================================================
+inline Standard_Boolean gp_Dir2d::IsEqual (const gp_Dir2d& theOther,
+                                           const Standard_Real theAngularTolerance) const
+{
+  Standard_Real anAng = Angle (theOther);
+  if (anAng < 0)
+  {
+    anAng = -anAng;
+  }
+  return anAng <= theAngularTolerance;
+}
 
+// =======================================================================
+// function : IsNormal
+// purpose  :
+// =======================================================================
+inline Standard_Boolean gp_Dir2d::IsNormal (const gp_Dir2d& theOther,
+                                            const Standard_Real theAngularTolerance) const
+{
+  Standard_Real anAng = Angle (theOther);
+  if (anAng < 0)
+  {
+    anAng = -anAng;
+  }
+  anAng = M_PI / 2.0 - anAng;
+  if (anAng < 0)
+  {
+    anAng = -anAng;
+  }
+  return anAng <= theAngularTolerance;
+}
 
+// =======================================================================
+// function : IsOpposite
+// purpose  :
+// =======================================================================
+inline Standard_Boolean gp_Dir2d::IsOpposite (const gp_Dir2d& theOther,
+                                              const Standard_Real theAngularTolerance) const
+{ 
+  Standard_Real anAng = Angle (theOther);
+  if (anAng < 0)
+  {
+    anAng = -anAng;
+  }
+  return M_PI - anAng <= theAngularTolerance;
+}
 
+// =======================================================================
+// function : IsParallel
+// purpose  :
+// =======================================================================
+inline Standard_Boolean gp_Dir2d::IsParallel (const gp_Dir2d& theOther,
+                                              const Standard_Real theAngularTolerance) const
+{
+  Standard_Real anAng = Angle (theOther);
+  if (anAng < 0)
+  {
+    anAng = -anAng;
+  }
+  return anAng <= theAngularTolerance || M_PI - anAng <= theAngularTolerance;
+}
 
+// =======================================================================
+// function : Rotate
+// purpose  :
+// =======================================================================
+inline void gp_Dir2d::Rotate (const Standard_Real theAng)
+{
+  gp_Trsf2d aT;
+  aT.SetRotation (gp_Pnt2d (0.0, 0.0), theAng);
+  coord.Multiply (aT.HVectorialPart());
+}
 
 #endif // _gp_Dir2d_HeaderFile
diff --git a/src/gp/gp_Dir2d.lxx b/src/gp/gp_Dir2d.lxx
deleted file mode 100644 (file)
index a60eb59..0000000
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// Modif JCV 08/01/91 introduction classe XY dans le package gp
-
-#include <Standard_ConstructionError.hxx>
-#include <Standard_OutOfRange.hxx>
-#include <gp_XY.hxx>
-#include <gp_Ax2d.hxx>
-#include <gp_Trsf2d.hxx>
-
-inline gp_Dir2d::gp_Dir2d() : coord (1.,0.) 
-{
-}
-
-inline gp_Dir2d::gp_Dir2d (const gp_Vec2d& V)
-{
-  const gp_XY& XY = V.XY();
-  Standard_Real X = XY.X();
-  Standard_Real Y = XY.Y();
-  Standard_Real D = sqrt(X * X + Y * Y);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir2d() - input vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-}
-
-inline gp_Dir2d::gp_Dir2d (const gp_XY& XY)
-{
-  Standard_Real X = XY.X();
-  Standard_Real Y = XY.Y();
-  Standard_Real D = sqrt(X * X + Y * Y);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir2d() - input vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-}
-
-inline gp_Dir2d::gp_Dir2d (const Standard_Real Xv,
-                          const Standard_Real Yv)
-{
-  Standard_Real D = sqrt (Xv * Xv + Yv * Yv);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir2d() - input vector has zero norm");
-  coord.SetX(Xv / D);
-  coord.SetY(Yv / D);
-}
-
-inline void gp_Dir2d::SetCoord (const Standard_Integer Index,
-                               const Standard_Real Xi)
-{
-  Standard_Real X = coord.X();
-  Standard_Real Y = coord.Y();
-  Standard_OutOfRange_Raise_if (Index < 1 || Index > 2, "gp_Dir2d::SetCoord() - index is out of range [1, 2]");
-  if      (Index == 1) X = Xi;
-  else                 Y = Xi;
-  Standard_Real D = sqrt (X * X + Y * Y);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir2d::SetCoord() - result vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-}
-
-inline void gp_Dir2d::SetCoord (const Standard_Real Xv,
-                               const Standard_Real Yv)
-{
-  Standard_Real D = sqrt (Xv * Xv + Yv * Yv);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir2d::SetCoord() - result vector has zero norm");
-  coord.SetX(Xv / D);
-  coord.SetY(Yv / D);
-}
-
-inline void gp_Dir2d::SetX (const Standard_Real X)
-{
-  Standard_Real Y = coord.Y();
-  Standard_Real D = sqrt (X * X + Y * Y);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir2d::SetX() - result vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-}
-
-inline void gp_Dir2d::SetY (const Standard_Real Y)
-{
-  Standard_Real X = coord.X();
-  Standard_Real D = sqrt (X * X + Y * Y);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir2d::SetY() - result vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-}
-
-inline void gp_Dir2d::SetXY (const gp_XY& XY)
-{
-  Standard_Real X = XY.X();
-  Standard_Real Y = XY.Y();
-  Standard_Real D = sqrt(X * X + Y * Y);
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "gp_Dir2d::SetZ() - result vector has zero norm");
-  coord.SetX(X / D);
-  coord.SetY(Y / D);
-}
-
-inline Standard_Real gp_Dir2d::Coord (const Standard_Integer Index) const
-{ return coord.Coord(Index); }
-
-inline void gp_Dir2d::Coord(Standard_Real& Xv, Standard_Real& Yv) const
-{ coord.Coord (Xv, Yv); }
-
-inline Standard_Real gp_Dir2d::X() const
-{ return coord.X() ; }    
-
-inline Standard_Real gp_Dir2d::Y() const
-{ return coord.Y() ; }
-
-inline const gp_XY& gp_Dir2d::XY () const
-{ return coord; }
-
-inline Standard_Boolean gp_Dir2d::IsEqual
-(const gp_Dir2d& Other,
- const Standard_Real AngularTolerance) const
-{
-  Standard_Real Ang = Angle(Other);
-  if (Ang < 0) Ang = - Ang;
-  return   Ang <= AngularTolerance;
-}    
-
-inline Standard_Boolean gp_Dir2d::IsNormal
-(const gp_Dir2d& Other,
- const Standard_Real AngularTolerance) const
-{
-  Standard_Real Ang = Angle(Other);
-  if (Ang < 0) Ang = - Ang;
-  Ang = M_PI / 2.0 - Ang;
-  if (Ang < 0) Ang = - Ang;
-  return   Ang <= AngularTolerance;
-}    
-
-inline Standard_Boolean gp_Dir2d::IsOpposite
-(const gp_Dir2d& Other,
- const Standard_Real AngularTolerance) const
-{ 
-  Standard_Real Ang = Angle(Other);
-  if (Ang < 0) Ang = - Ang;
-  return M_PI - Ang <= AngularTolerance;
-}    
-
-inline Standard_Boolean gp_Dir2d::IsParallel
-(const gp_Dir2d& Other,
- const Standard_Real AngularTolerance) const
-{
-  Standard_Real Ang = Angle(Other);
-  if (Ang < 0) Ang = - Ang;
-  return   Ang <= AngularTolerance || M_PI - Ang <= AngularTolerance;
-}    
-
-inline Standard_Real gp_Dir2d::Crossed (const gp_Dir2d& Right) const
-{ return coord.Crossed (Right.coord); }
-
-inline Standard_Real gp_Dir2d::Dot (const gp_Dir2d& Other) const
-{ return coord.Dot (Other.coord); }
-
-inline void gp_Dir2d::Reverse()
-{ coord.Reverse(); }
-
-inline gp_Dir2d gp_Dir2d::Reversed() const
-{ 
-  gp_Dir2d V = *this;
-  V.coord.Reverse ();
-  return V;
-}
-
-inline void gp_Dir2d::Rotate (const Standard_Real Ang)
-{
-  gp_Trsf2d T;
-  T.SetRotation (gp_Pnt2d (0.0, 0.0), Ang);
-  coord.Multiply (T.HVectorialPart());
-}
-
-inline gp_Dir2d gp_Dir2d::Rotated (const Standard_Real Ang) const
-{
-  gp_Dir2d V = *this;
-  V.Rotate (Ang);
-  return V;
-}
-
-inline gp_Dir2d gp_Dir2d::Transformed (const gp_Trsf2d& T) const
-{
-  gp_Dir2d V = *this;
-  V.Transform (T);
-  return V;
-} 
-
index d0bc04e..e9b0632 100644 (file)
 
 //Modif JCV 12/12/90
 
+#include <gp_Elips.hxx>
+
 #include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
-#include <gp_Elips.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Trsf.hxx>
 #include <gp_Vec.hxx>
index 11e3789..b4f2491 100644 (file)
 #ifndef _gp_Elips_HeaderFile
 #define _gp_Elips_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <gp_Ax2.hxx>
-#include <Standard_Real.hxx>
+#include <gp.hxx>
 #include <gp_Ax1.hxx>
+#include <gp_Ax2.hxx>
 #include <gp_Pnt.hxx>
-class Standard_ConstructionError;
-class gp_Ax2;
-class gp_Ax1;
-class gp_Pnt;
-class gp_Trsf;
-class gp_Vec;
-
-
+#include <Standard_ConstructionError.hxx>
 
 //! Describes an ellipse in 3D space.
 //! An ellipse is defined by its major and minor radii and
@@ -63,60 +52,74 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an indefinite ellipse.
-    gp_Elips();
-  
+  gp_Elips()
+  : majorRadius (RealLast()),
+    minorRadius (RealSmall())
+  {}
 
   //! The major radius of the ellipse is on the "XAxis" and the
   //! minor radius is on the "YAxis" of the ellipse. The "XAxis"
-  //! is defined with the "XDirection" of A2 and the "YAxis" is
-  //! defined with the "YDirection" of A2.
+  //! is defined with the "XDirection" of theA2 and the "YAxis" is
+  //! defined with the "YDirection" of theA2.
   //! Warnings :
-  //! It is not forbidden to create an ellipse with MajorRadius =
-  //! MinorRadius.
-  //! Raises ConstructionError if MajorRadius < MinorRadius or MinorRadius < 0.
-    gp_Elips(const gp_Ax2& A2, const Standard_Real MajorRadius, const Standard_Real MinorRadius);
-  
+  //! It is not forbidden to create an ellipse with theMajorRadius =
+  //! theMinorRadius.
+  //! Raises ConstructionError if theMajorRadius < theMinorRadius or theMinorRadius < 0.
+  gp_Elips (const gp_Ax2& theA2, const Standard_Real theMajorRadius, const Standard_Real theMinorRadius)
+  : pos (theA2),
+    majorRadius (theMajorRadius),
+    minorRadius (theMinorRadius)
+  {
+    Standard_ConstructionError_Raise_if (theMinorRadius < 0.0 || theMajorRadius < theMinorRadius,
+      "gp_Elips() - invalid construction parameters");
+  }
 
   //! Changes the axis normal to the plane of the ellipse.
   //! It modifies the definition of this plane.
   //! The "XAxis" and the "YAxis" are recomputed.
   //! The local coordinate system is redefined so that:
   //! -   its origin and "main Direction" become those of the
-  //! axis A1 (the "X Direction" and "Y Direction" are then
+  //! axis theA1 (the "X Direction" and "Y Direction" are then
   //! recomputed in the same way as for any gp_Ax2), or
-  //! Raises ConstructionError if the direction of A1
+  //! Raises ConstructionError if the direction of theA1
   //! is parallel to the direction of the "XAxis" of the ellipse.
-    void SetAxis (const gp_Ax1& A1);
-  
+  void SetAxis (const gp_Ax1& theA1) { pos.SetAxis (theA1); }
+
   //! Modifies this ellipse, by redefining its local coordinate
-  //! so that its origin becomes P.
-    void SetLocation (const gp_Pnt& P);
-  
+  //! so that its origin becomes theP.
+  void SetLocation (const gp_Pnt& theP) { pos.SetLocation (theP); }
 
   //! The major radius of the ellipse is on the "XAxis" (major axis)
   //! of the ellipse.
-  //! Raises ConstructionError if MajorRadius < MinorRadius.
-    void SetMajorRadius (const Standard_Real MajorRadius);
-  
+  //! Raises ConstructionError if theMajorRadius < MinorRadius.
+  void SetMajorRadius (const Standard_Real theMajorRadius)
+  {
+    Standard_ConstructionError_Raise_if (theMajorRadius < minorRadius,
+       "gp_Elips::SetMajorRadius() - major radius should be greater or equal to minor radius");
+    majorRadius = theMajorRadius;
+  }
 
   //! The minor radius of the ellipse is on the "YAxis" (minor axis)
   //! of the ellipse.
-  //! Raises ConstructionError if MinorRadius > MajorRadius or MinorRadius < 0.
-    void SetMinorRadius (const Standard_Real MinorRadius);
-  
+  //! Raises ConstructionError if theMinorRadius > MajorRadius or MinorRadius < 0.
+  void SetMinorRadius (const Standard_Real theMinorRadius)
+  {
+    Standard_ConstructionError_Raise_if (theMinorRadius < 0.0 || majorRadius < theMinorRadius,
+      "gp_Elips::SetMinorRadius() - minor radius should be a positive number lesser or equal to major radius");
+    minorRadius = theMinorRadius;
+  }
+
   //! Modifies this ellipse, by redefining its local coordinate
-  //! so that it becomes A2e.
-    void SetPosition (const gp_Ax2& A2);
-  
+  //! so that it becomes theA2.
+  void SetPosition (const gp_Ax2& theA2) { pos = theA2; }
+
   //! Computes the area of the Ellipse.
-    Standard_Real Area() const;
-  
+  Standard_Real Area() const { return M_PI * majorRadius * minorRadius; }
 
   //! Computes the axis normal to the plane of the ellipse.
-    const gp_Ax1& Axis() const;
-  
+  const gp_Ax1& Axis() const { return pos.Axis(); }
+
   //! Computes the first or second directrix of this ellipse.
   //! These are the lines, in the plane of the ellipse, normal to
   //! the major axis, at a distance equal to
@@ -131,149 +134,304 @@ public:
   //! Exceptions
   //! Standard_ConstructionError if the eccentricity is null
   //! (the ellipse has degenerated into a circle).
-    gp_Ax1 Directrix1() const;
-  
+  gp_Ax1 Directrix1() const;
 
   //! This line is obtained by the symmetrical transformation
   //! of "Directrix1" with respect to the "YAxis" of the ellipse.
   //! Exceptions
   //! Standard_ConstructionError if the eccentricity is null
   //! (the ellipse has degenerated into a circle).
-    gp_Ax1 Directrix2() const;
-  
+  gp_Ax1 Directrix2() const;
 
   //! Returns the eccentricity of the ellipse  between 0.0 and 1.0
   //! If f is the distance between the center of the ellipse and
   //! the Focus1 then the eccentricity e = f / MajorRadius.
   //! Raises ConstructionError if MajorRadius = 0.0
-    Standard_Real Eccentricity() const;
-  
+  Standard_Real Eccentricity() const;
 
   //! Computes the focal distance. It is the distance between the
   //! two focus focus1 and focus2 of the ellipse.
-    Standard_Real Focal() const;
-  
+  Standard_Real Focal() const
+  {
+    return 2.0 * sqrt (majorRadius * majorRadius - minorRadius * minorRadius);
+  }
 
   //! Returns the first focus of the ellipse. This focus is on the
   //! positive side of the "XAxis" of the ellipse.
-    gp_Pnt Focus1() const;
-  
+  gp_Pnt Focus1() const;
 
   //! Returns the second focus of the ellipse. This focus is on the
   //! negative side of the "XAxis" of the ellipse.
-    gp_Pnt Focus2() const;
-  
+  gp_Pnt Focus2() const;
 
   //! Returns the center of the ellipse. It is the "Location"
   //! point of the coordinate system of the ellipse.
-    const gp_Pnt& Location() const;
-  
+  const gp_Pnt& Location() const { return pos.Location(); }
+
   //! Returns the major radius of the ellipse.
-    Standard_Real MajorRadius() const;
-  
+  Standard_Real MajorRadius() const { return majorRadius; }
+
   //! Returns the minor radius of the ellipse.
-    Standard_Real MinorRadius() const;
-  
+  Standard_Real MinorRadius() const { return minorRadius; }
 
   //! Returns p = (1 - e * e) * MajorRadius where e is the eccentricity
   //! of the ellipse.
   //! Returns 0 if MajorRadius = 0
-    Standard_Real Parameter() const;
-  
+  Standard_Real Parameter() const;
+
   //! Returns the coordinate system of the ellipse.
-    const gp_Ax2& Position() const;
-  
+  const gp_Ax2& Position() const { return pos; }
 
   //! Returns the "XAxis" of the ellipse whose origin
   //! is the center of this ellipse. It is the major axis of the
   //! ellipse.
-    gp_Ax1 XAxis() const;
-  
+  gp_Ax1 XAxis() const { return gp_Ax1 (pos.Location(), pos.XDirection()); }
 
   //! Returns the "YAxis" of the ellipse whose unit vector is the "X Direction" or the "Y Direction"
   //! of the local coordinate system of this ellipse.
   //! This is the minor axis of the ellipse.
-    gp_Ax1 YAxis() const;
-  
-  Standard_EXPORT void Mirror (const gp_Pnt& P);
-  
+  gp_Ax1 YAxis() const { return gp_Ax1 (pos.Location(), pos.YDirection()); }
+
+  Standard_EXPORT void Mirror (const gp_Pnt& theP);
 
   //! Performs the symmetrical transformation of an ellipse with
-  //! respect to the point P which is the center of the symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Elips Mirrored (const gp_Pnt& P) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax1& A1);
-  
+  //! respect to the point theP which is the center of the symmetry.
+  Standard_NODISCARD Standard_EXPORT gp_Elips Mirrored (const gp_Pnt& theP) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax1& theA1);
 
   //! Performs the symmetrical transformation of an ellipse with
   //! respect to an axis placement which is the axis of the symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Elips Mirrored (const gp_Ax1& A1) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2& A2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Elips Mirrored (const gp_Ax1& theA1) const;
+
+  Standard_EXPORT void Mirror (const gp_Ax2& theA2);
 
   //! Performs the symmetrical transformation of an ellipse with
-  //! respect to a plane. The axis placement A2 locates the plane
+  //! respect to a plane. The axis placement theA2 locates the plane
   //! of the symmetry (Location, XDirection, YDirection).
-  Standard_NODISCARD Standard_EXPORT gp_Elips Mirrored (const gp_Ax2& A2) const;
-  
-    void Rotate (const gp_Ax1& A1, const Standard_Real Ang);
-  
-
-  //! Rotates an ellipse. A1 is the axis of the rotation.
-  //! Ang is the angular value of the rotation in radians.
-    Standard_NODISCARD gp_Elips Rotated (const gp_Ax1& A1, const Standard_Real Ang) const;
-  
-    void Scale (const gp_Pnt& P, const Standard_Real S);
-  
-
-  //! Scales an ellipse. S is the scaling value.
-    Standard_NODISCARD gp_Elips Scaled (const gp_Pnt& P, const Standard_Real S) const;
-  
-    void Transform (const gp_Trsf& T);
-  
-
-  //! Transforms an ellipse with the transformation T from class Trsf.
-    Standard_NODISCARD gp_Elips Transformed (const gp_Trsf& T) const;
-  
-    void Translate (const gp_Vec& V);
-  
-
-  //! Translates an ellipse in the direction of the vector V.
-  //! The magnitude of the translation is the vector's magnitude.
-    Standard_NODISCARD gp_Elips Translated (const gp_Vec& V) const;
-  
-    void Translate (const gp_Pnt& P1, const gp_Pnt& P2);
-  
+  Standard_NODISCARD Standard_EXPORT gp_Elips Mirrored (const gp_Ax2& theA2) const;
 
-  //! Translates an ellipse from the point P1 to the point P2.
-    Standard_NODISCARD gp_Elips Translated (const gp_Pnt& P1, const gp_Pnt& P2) const;
+  void Rotate (const gp_Ax1& theA1, const Standard_Real theAng) { pos.Rotate (theA1, theAng); }
 
+  //! Rotates an ellipse. theA1 is the axis of the rotation.
+  //! theAng is the angular value of the rotation in radians.
+  Standard_NODISCARD gp_Elips Rotated (const gp_Ax1& theA1, const Standard_Real theAng) const
+  {
+    gp_Elips anE = *this;
+    anE.pos.Rotate (theA1, theAng);
+    return anE;
+  }
 
+  void Scale (const gp_Pnt& theP, const Standard_Real theS);
 
+  //! Scales an ellipse. theS is the scaling value.
+  Standard_NODISCARD gp_Elips Scaled (const gp_Pnt& theP, const Standard_Real theS) const;
 
-protected:
-
+  void Transform (const gp_Trsf& theT);
 
+  //! Transforms an ellipse with the transformation theT from class Trsf.
+  Standard_NODISCARD gp_Elips Transformed (const gp_Trsf& theT) const;
 
+  void Translate (const gp_Vec& theV) { pos.Translate (theV); }
 
+  //! Translates an ellipse in the direction of the vector theV.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Elips Translated (const gp_Vec& theV) const
+  {
+    gp_Elips anE = *this;
+    anE.pos.Translate (theV);
+    return anE;
+  }
+
+  void Translate (const gp_Pnt& theP1, const gp_Pnt& theP2) { pos.Translate (theP1, theP2); }
+
+  //! Translates an ellipse from the point theP1 to the point theP2.
+  Standard_NODISCARD gp_Elips Translated (const gp_Pnt& theP1, const gp_Pnt& theP2) const
+  {
+    gp_Elips anE = *this;
+    anE.pos.Translate (theP1, theP2);
+    return anE;
+  }
 
 private:
 
-
-
   gp_Ax2 pos;
   Standard_Real majorRadius;
   Standard_Real minorRadius;
 
-
 };
 
-
-#include <gp_Elips.lxx>
-
-
-
-
+// =======================================================================
+// function : Directrix1
+// purpose  :
+// =======================================================================
+inline gp_Ax1 gp_Elips::Directrix1() const
+{
+  Standard_Real anE = Eccentricity();
+  Standard_ConstructionError_Raise_if (anE <= gp::Resolution(), "gp_Elips::Directrix1() - zero eccentricity");
+  gp_XYZ anOrig = pos.XDirection().XYZ();
+  anOrig.Multiply (majorRadius / anE);
+  anOrig.Add (pos.Location().XYZ());
+  return gp_Ax1 (gp_Pnt (anOrig), pos.YDirection());
+}
+
+// =======================================================================
+// function : Directrix2
+// purpose  :
+// =======================================================================
+inline gp_Ax1 gp_Elips::Directrix2() const
+{
+  Standard_Real anE = Eccentricity();
+  Standard_ConstructionError_Raise_if (anE <= gp::Resolution(), "gp_Elips::Directrix2() - zero eccentricity");
+  gp_XYZ anOrig = pos.XDirection().XYZ();
+  anOrig.Multiply (-majorRadius / anE);
+  anOrig.Add (pos.Location().XYZ());
+  return gp_Ax1 (gp_Pnt (anOrig), pos.YDirection());
+}
+
+// =======================================================================
+// function : Eccentricity
+// purpose  :
+// =======================================================================
+inline Standard_Real gp_Elips::Eccentricity() const
+{
+  if (majorRadius == 0.0)
+  {
+    return 0.0;
+  }
+  else
+  {
+    return sqrt (majorRadius * majorRadius - minorRadius * minorRadius) / majorRadius;
+  }
+}
+
+// =======================================================================
+// function : Focus1
+// purpose  :
+// =======================================================================
+inline gp_Pnt gp_Elips::Focus1() const
+{
+  Standard_Real aC = sqrt (majorRadius * majorRadius - minorRadius * minorRadius);
+  const gp_Pnt& aPP = pos.Location();
+  const gp_Dir& aDD = pos.XDirection();
+  return gp_Pnt (aPP.X() + aC * aDD.X(),
+                 aPP.Y() + aC * aDD.Y(),
+                 aPP.Z() + aC * aDD.Z());
+}
+
+// =======================================================================
+// function : Focus2
+// purpose  :
+// =======================================================================
+inline gp_Pnt gp_Elips::Focus2() const
+{
+  Standard_Real aC = sqrt (majorRadius * majorRadius - minorRadius * minorRadius);
+  const gp_Pnt& aPP = pos.Location();
+  const gp_Dir& aDD = pos.XDirection();
+  return gp_Pnt (aPP.X() - aC * aDD.X(),
+                 aPP.Y() - aC * aDD.Y(),
+                 aPP.Z() - aC * aDD.Z());
+}
+
+// =======================================================================
+// function : Parameter
+// purpose  :
+// =======================================================================
+inline Standard_Real gp_Elips::Parameter() const
+{
+  if (majorRadius == 0.0)
+  {
+    return 0.0;
+  }
+  else
+  {
+    return (minorRadius * minorRadius) / majorRadius;
+  }
+}
+
+// =======================================================================
+// function : Scale
+// purpose  :
+// =======================================================================
+inline void gp_Elips::Scale (const gp_Pnt& theP,
+                             const Standard_Real theS)
+  //  Modified by skv - Fri Apr  8 10:28:10 2005 OCC8559 Begin
+  // { pos.Scale(P, S); }
+{
+  majorRadius *= theS;
+  if (majorRadius < 0)
+  {
+    majorRadius = -majorRadius;
+  }
+  minorRadius *= theS;
+  if (minorRadius < 0)
+  {
+    minorRadius = -minorRadius;
+  }
+  pos.Scale (theP, theS);
+}
+//  Modified by skv - Fri Apr  8 10:28:10 2005 OCC8559 End
+
+// =======================================================================
+// function : Scaled
+// purpose  :
+// =======================================================================
+inline gp_Elips gp_Elips::Scaled (const gp_Pnt& theP,
+                                  const Standard_Real theS) const
+{
+  gp_Elips anE = *this;
+  anE.majorRadius *= theS;
+  if (anE.majorRadius < 0)
+  {
+    anE.majorRadius = -anE.majorRadius;
+  }
+  anE.minorRadius *= theS;
+  if (anE.minorRadius < 0)
+  {
+    anE.minorRadius = -anE.minorRadius;
+  }
+  anE.pos.Scale (theP, theS);
+  return anE;
+}
+
+// =======================================================================
+// function : Transform
+// purpose  :
+// =======================================================================
+inline void gp_Elips::Transform (const gp_Trsf& theT)
+{
+  majorRadius *= theT.ScaleFactor();
+  if (majorRadius < 0)
+  {
+    majorRadius = -majorRadius;
+  }
+  minorRadius *= theT.ScaleFactor();
+  if (minorRadius < 0)
+  {
+    minorRadius = -minorRadius;
+  }
+  pos.Transform (theT);
+}
+
+// =======================================================================
+// function : Transformed
+// purpose  :
+// =======================================================================
+inline gp_Elips gp_Elips::Transformed (const gp_Trsf& theT) const
+{
+  gp_Elips anE = *this;
+  anE.majorRadius *= theT.ScaleFactor();
+  if (anE.majorRadius < 0)
+  {
+    anE.majorRadius = -anE.majorRadius;
+  }
+  anE.minorRadius *= theT.ScaleFactor();
+  if (anE.minorRadius < 0)
+  {
+    anE.minorRadius = -anE.minorRadius;
+  }
+  anE.pos.Transform (theT);
+  return anE;
+}
 
 #endif // _gp_Elips_HeaderFile
diff --git a/src/gp/gp_Elips.lxx b/src/gp/gp_Elips.lxx
deleted file mode 100644 (file)
index 543cb71..0000000
+++ /dev/null
@@ -1,224 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//  Modified by skv - Fri Apr  8 10:28:10 2005 OCC8559
-
-
-#include <gp.hxx>
-#include <Standard_ConstructionError.hxx>
-
-inline gp_Elips::gp_Elips () :
-majorRadius (RealLast()),
-minorRadius (RealSmall())
-{ }
-
-inline gp_Elips::gp_Elips (const gp_Ax2& A2,
-                          const Standard_Real MajorRadius,
-                          const Standard_Real MinorRadius) :
-                          pos(A2),
-                          majorRadius (MajorRadius),
-                          minorRadius (MinorRadius)
-{ 
-  Standard_ConstructionError_Raise_if (MinorRadius < 0.0 || MajorRadius < MinorRadius,
-                                       "gp_Elips() - invalid construction parameters");
-}
-
-inline Standard_Real gp_Elips::Area() const
-{ return M_PI * majorRadius * minorRadius; }
-
-inline Standard_Real gp_Elips::MajorRadius() const
-{ return majorRadius; }
-
-inline Standard_Real gp_Elips::MinorRadius() const
-{ return minorRadius; }
-
-inline Standard_Real gp_Elips::Parameter() const
-{ 
-  if (majorRadius == 0.0) return 0.0;
-  else                    return (minorRadius * minorRadius) / majorRadius;
-}
-
-inline const gp_Ax2& gp_Elips::Position() const
-{ return pos; }
-
-inline const gp_Ax1& gp_Elips::Axis ()     const
-{ return pos.Axis(); }
-
-inline gp_Ax1 gp_Elips::Directrix1() const
-{
-  Standard_Real E = Eccentricity();
-  Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "gp_Elips::Directrix1() - zero eccentricity");
-  gp_XYZ Orig = pos.XDirection().XYZ();
-  Orig.Multiply (majorRadius/E);
-  Orig.Add (pos.Location().XYZ());
-  return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
-}
-
-inline gp_Ax1 gp_Elips::Directrix2() const
-{
-  Standard_Real E = Eccentricity();
-  Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "gp_Elips::Directrix2() - zero eccentricity");
-  gp_XYZ Orig = pos.XDirection().XYZ();
-  Orig.Multiply (-majorRadius/E);
-  Orig.Add (pos.Location().XYZ());
-  return gp_Ax1 (gp_Pnt(Orig), pos.YDirection());
-}
-
-inline Standard_Real gp_Elips::Eccentricity() const
-{
-  if (majorRadius == 0.0) { return 0.0; }
-  else {
-    return sqrt(majorRadius * majorRadius - 
-               minorRadius * minorRadius) / majorRadius;
-  }
-}
-
-inline Standard_Real gp_Elips::Focal() const
-{
-  return 2.0 * sqrt(majorRadius * majorRadius -
-                   minorRadius * minorRadius);
-}
-
-inline gp_Pnt gp_Elips::Focus1() const
-{
-  Standard_Real C = sqrt(majorRadius * majorRadius -
-                        minorRadius * minorRadius);
-  const gp_Pnt& PP = pos.Location  ();
-  const gp_Dir& DD = pos.XDirection();
-  return gp_Pnt (PP.X() + C * DD.X(),
-                PP.Y() + C * DD.Y(),
-                PP.Z() + C * DD.Z());
-}
-
-inline gp_Pnt gp_Elips::Focus2() const
-{
-  Standard_Real C = sqrt(majorRadius * majorRadius -
-                        minorRadius * minorRadius);
-  const gp_Pnt& PP = pos.Location  ();
-  const gp_Dir& DD = pos.XDirection();
-  return gp_Pnt (PP.X() - C * DD.X(),
-                PP.Y() - C * DD.Y(),
-                PP.Z() - C * DD.Z());
-}
-
-inline const gp_Pnt& gp_Elips::Location () const
-{ return pos.Location(); }
-
-inline gp_Ax1 gp_Elips::XAxis () const
-{ return gp_Ax1 (pos.Location(), pos.XDirection()); }
-
-inline gp_Ax1 gp_Elips::YAxis () const
-{ return gp_Ax1 (pos.Location(), pos.YDirection()); }
-
-inline void gp_Elips::SetAxis (const gp_Ax1& A1)
-{ pos.SetAxis(A1); }
-
-inline void gp_Elips::SetPosition (const gp_Ax2& A2)
-{ pos = A2; }
-
-inline void gp_Elips::SetLocation (const gp_Pnt& P)
-{ pos.SetLocation (P); }
-
-inline void gp_Elips::SetMajorRadius (const Standard_Real R)
-{ 
-  Standard_ConstructionError_Raise_if (R < minorRadius,
-                                       "gp_Elips::SetMajorRadius() - major radius should be greater or equal to minor radius");
-  majorRadius = R;
-}
-
-inline void gp_Elips::SetMinorRadius (const Standard_Real R)
-{ 
-  Standard_ConstructionError_Raise_if (R < 0.0 || majorRadius < R,
-                                       "gp_Elips::SetMinorRadius() - minor radius should be a positive number lesser or equal to major radius");
-  minorRadius = R;
-}
-
-inline void gp_Elips::Rotate (const gp_Ax1& A1,
-                             const Standard_Real Ang) { pos.Rotate(A1, Ang); }
-
-inline gp_Elips gp_Elips::Rotated (const gp_Ax1& A1,
-                                  const Standard_Real Ang) const
-{
-  gp_Elips E = *this;
-  E.pos.Rotate(A1, Ang);
-  return E; 
-}
-
-inline void gp_Elips::Scale (const gp_Pnt& P,
-                            const Standard_Real S)
-//  Modified by skv - Fri Apr  8 10:28:10 2005 OCC8559 Begin
-// { pos.Scale(P, S); }
-{
-  majorRadius *= S;
-  if (majorRadius < 0) majorRadius = - majorRadius;
-  minorRadius *= S;
-  if (minorRadius < 0) minorRadius = - minorRadius;
-  pos.Scale(P, S);
-}
-//  Modified by skv - Fri Apr  8 10:28:10 2005 OCC8559 End
-
-inline gp_Elips gp_Elips::Scaled (const gp_Pnt& P,
-                                 const Standard_Real S) const
-{
-  gp_Elips E = *this;
-  E.majorRadius *= S;
-  if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
-  E.minorRadius *= S;
-  if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
-  E.pos.Scale(P, S);
-  return E; 
-}
-
-inline void gp_Elips::Transform (const gp_Trsf& T)
-{
-  majorRadius *= T.ScaleFactor();
-  if (majorRadius < 0) majorRadius = - majorRadius;
-  minorRadius *= T.ScaleFactor();
-  if (minorRadius < 0) minorRadius = - minorRadius;
-  pos.Transform(T);
-}
-
-inline gp_Elips gp_Elips::Transformed (const gp_Trsf& T) const
-{
-  gp_Elips E = *this;
-  E.majorRadius *= T.ScaleFactor();
-  if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
-  E.minorRadius *= T.ScaleFactor();
-  if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
-  E.pos.Transform(T);
-  return E;
-}
-
-inline void gp_Elips::Translate (const gp_Vec& V) 
-{ pos.Translate(V); }
-
-inline gp_Elips gp_Elips::Translated (const gp_Vec& V) const 
-{
-  gp_Elips E = *this;
-  E.pos.Translate(V);
-  return E; 
-}
-
-inline void gp_Elips::Translate (const gp_Pnt& P1,
-                         const gp_Pnt& P2)
-{  pos.Translate(P1, P2); }
-
-inline gp_Elips gp_Elips::Translated (const gp_Pnt& P1,
-                                     const gp_Pnt& P2) const
-{
-  gp_Elips E = *this;
-  E.pos.Translate(P1, P2);
-  return E; 
-}
-
index 3be08b9..97c4194 100644 (file)
 
 //Modif JCV 10/01/91
 
+#include <gp_Elips2d.hxx>
+
 #include <gp_Ax2d.hxx>
 #include <gp_Ax22d.hxx>
-#include <gp_Elips2d.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_Trsf2d.hxx>
 #include <gp_Vec2d.hxx>
index 0a1dc05..780539d 100644 (file)
 #ifndef _gp_Elips2d_HeaderFile
 #define _gp_Elips2d_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
+#include <gp.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 an ellipse in the plane (2D space).
 //! An ellipse is defined by its major and minor radii and
@@ -59,76 +47,101 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Creates an indefinite ellipse.
-    gp_Elips2d();
-  
+  gp_Elips2d()
+  : majorRadius (RealLast()),
+    minorRadius (RealSmall())
+  {}
 
   //! Creates an ellipse with the major axis, the major and the
-  //! minor radius. The location of the MajorAxis is the center
+  //! minor radius. The location of the theMajorAxis is the center
   //! of the  ellipse.
-  //! The sense of parametrization is given by Sense.
+  //! The sense of parametrization is given by theIsSense.
   //! Warnings :
   //! It is possible to create an ellipse with
-  //! MajorRadius = MinorRadius.
-  //! Raises ConstructionError if MajorRadius < MinorRadius or MinorRadius < 0.0
-    gp_Elips2d(const gp_Ax2d& MajorAxis, const Standard_Real MajorRadius, const Standard_Real MinorRadius, const Standard_Boolean Sense = Standard_True);
-  
+  //! theMajorRadius = theMinorRadius.
+  //! Raises ConstructionError if theMajorRadius < theMinorRadius or theMinorRadius < 0.0
+  gp_Elips2d (const gp_Ax2d& theMajorAxis, const Standard_Real theMajorRadius,
+              const Standard_Real theMinorRadius, const Standard_Boolean theIsSense = Standard_True)
+  : majorRadius (theMajorRadius),
+    minorRadius (theMinorRadius)
+  {
+    pos = gp_Ax22d (theMajorAxis, theIsSense);
+    Standard_ConstructionError_Raise_if (theMinorRadius < 0.0 || theMajorRadius < theMinorRadius,
+      "gp_Elips2d() - invalid construction parameters");
+  }
+
   //! Creates an ellipse with radii MajorRadius and
-  //! MinorRadius, positioned in the plane by coordinate system A where:
-  //! -   the origin of A is the center of the ellipse,
-  //! -   the "X Direction" of A defines the major axis of
+  //! MinorRadius, positioned in the plane by coordinate system theA where:
+  //! -   the origin of theA is the center of the ellipse,
+  //! -   the "X Direction" of theA defines the major axis of
   //! the ellipse, that is, the major radius MajorRadius
   //! is measured along this axis, and
-  //! -   the "Y Direction" of A defines the minor axis of
-  //! the ellipse, that is, the minor radius MinorRadius
+  //! -   the "Y Direction" of theA defines the minor axis of
+  //! the ellipse, that is, the minor radius theMinorRadius
   //! is measured along this axis, and
-  //! -   the orientation (direct or indirect sense) of A
+  //! -   the orientation (direct or indirect sense) of theA
   //! gives the orientation of the ellipse.
   //! Warnings :
   //! It is possible to create an ellipse with
-  //! MajorRadius = MinorRadius.
-  //! Raises ConstructionError if MajorRadius < MinorRadius or MinorRadius < 0.0
-  gp_Elips2d(const gp_Ax22d& A, const Standard_Real MajorRadius, const Standard_Real MinorRadius);
-  
+  //! theMajorRadius = theMinorRadius.
+  //! Raises ConstructionError if theMajorRadius < theMinorRadius or theMinorRadius < 0.0
+  gp_Elips2d (const gp_Ax22d& theA, const Standard_Real theMajorRadius, const Standard_Real theMinorRadius)
+  : pos (theA),
+    majorRadius (theMajorRadius),
+    minorRadius (theMinorRadius)
+  {
+    Standard_ConstructionError_Raise_if (theMinorRadius < 0.0 || theMajorRadius < theMinorRadius,
+      "gp_Elips2d() - invalid construction parameters");
+  }
+
   //! Modifies this ellipse, by redefining its local coordinate system so that
-  //! -   its origin becomes P.
-  void SetLocation (const gp_Pnt2d& P);
-  
+  //! -   its origin becomes theP.
+  void SetLocation (const gp_Pnt2d& theP) { pos.SetLocation (theP); }
+
   //! Changes the value of the major radius.
-  //! Raises ConstructionError if MajorRadius < MinorRadius.
-  void SetMajorRadius (const Standard_Real MajorRadius);
+  //! Raises ConstructionError if theMajorRadius < MinorRadius.
+  void SetMajorRadius (const Standard_Real theMajorRadius)
+  {
+    Standard_ConstructionError_Raise_if (theMajorRadius < minorRadius,
+      "gp_Elips2d::SetMajorRadius() - major radius should be greater or equal to minor radius");
+    majorRadius = theMajorRadius;
+  }
   
   //! Changes the value of the minor radius.
-  //! Raises ConstructionError if MajorRadius < MinorRadius or MinorRadius < 0.0
-  void SetMinorRadius (const Standard_Real MinorRadius);
-  
+  //! Raises ConstructionError if MajorRadius < theMinorRadius or MinorRadius < 0.0
+  void SetMinorRadius (const Standard_Real theMinorRadius)
+  {
+    Standard_ConstructionError_Raise_if (theMinorRadius < 0.0 || majorRadius < theMinorRadius,
+      "gp_Elips2d::SetMinorRadius() - minor radius should be a positive number lesser or equal to major radius");
+    minorRadius = theMinorRadius;
+  }
+
   //! Modifies this ellipse, by redefining its local coordinate system so that
-  //! it becomes A.
-  void SetAxis (const gp_Ax22d& A);
-  
+  //! it becomes theA.
+  void SetAxis (const gp_Ax22d& theA) { pos.SetAxis (theA); }
+
   //! Modifies this ellipse, by redefining its local coordinate system so that
   //! its origin and its "X Direction"  become those
-  //! of the axis A. The "Y  Direction"  is then
+  //! of the axis theA. The "Y  Direction"  is then
   //! recomputed. The orientation of the local coordinate
   //! system is not modified.
-  void SetXAxis (const gp_Ax2d& A);
-  
+  void SetXAxis (const gp_Ax2d& theA) { pos.SetXAxis (theA); }
+
   //! Modifies this ellipse, by redefining its local coordinate system so that
   //! its origin and its "Y Direction"  become those
-  //! of the axis A. The "X  Direction"  is then
+  //! of the axis theA. The "X  Direction"  is then
   //! recomputed. The orientation of the local coordinate
   //! system is not modified.
-  void SetYAxis (const gp_Ax2d& A);
-  
+  void SetYAxis (const gp_Ax2d& theA) { pos.SetYAxis (theA); }
+
   //! Computes the area of the ellipse.
-    Standard_Real Area() const;
-  
+  Standard_Real Area() const { return M_PI * majorRadius * minorRadius; }
 
   //! Returns the coefficients of the implicit equation of the ellipse.
-  //! A * (X**2) + B * (Y**2) + 2*C*(X*Y) + 2*D*X + 2*E*Y + F = 0.
-  Standard_EXPORT void Coefficients (Standard_Real& A, Standard_Real& B, Standard_Real& C, Standard_Real& D, Standard_Real& E, Standard_Real& F) const;
-  
+  //! theA * (X**2) + theB * (Y**2) + 2*theC*(X*Y) + 2*theD*X + 2*theE*Y + theF = 0.
+  Standard_EXPORT void Coefficients (Standard_Real& theA, Standard_Real& theB, Standard_Real& theC,
+                                     Standard_Real& theD, Standard_Real& theE, Standard_Real& theF) const;
 
   //! This directrix is the line normal to the XAxis of the ellipse
   //! in the local plane (Z = 0) at a distance d = MajorRadius / e
@@ -140,139 +153,308 @@ public:
   //!
   //! Raised if Eccentricity = 0.0. (The ellipse degenerates into a
   //! circle)
-    gp_Ax2d Directrix1() const;
-  
+  gp_Ax2d Directrix1() const;
 
   //! This line is obtained by the symmetrical transformation
   //! of "Directrix1" with respect to the minor axis of the ellipse.
   //!
   //! Raised if Eccentricity = 0.0. (The ellipse degenerates into a
   //! circle).
-    gp_Ax2d Directrix2() const;
-  
+  gp_Ax2d Directrix2() const;
 
   //! Returns the eccentricity of the ellipse  between 0.0 and 1.0
   //! If f is the distance between the center of the ellipse and
   //! the Focus1 then the eccentricity e = f / MajorRadius.
   //! Returns 0 if MajorRadius = 0.
-    Standard_Real Eccentricity() const;
-  
+  Standard_Real Eccentricity() const;
 
   //! Returns the distance between the center of the ellipse
   //! and focus1 or focus2.
-    Standard_Real Focal() const;
-  
+  Standard_Real Focal() const
+  {
+    return 2.0 * sqrt (majorRadius * majorRadius - minorRadius * minorRadius);
+  }
 
   //! Returns the first focus of the ellipse. This focus is on the
   //! positive side of the major axis of the ellipse.
-    gp_Pnt2d Focus1() const;
-  
+  gp_Pnt2d Focus1() const;
 
   //! Returns the second focus of the ellipse. This focus is on the
   //! negative side of the major axis of the ellipse.
-    gp_Pnt2d Focus2() const;
-  
+  gp_Pnt2d Focus2() const;
+
   //! Returns the center of the ellipse.
-    const gp_Pnt2d& Location() const;
-  
+  const gp_Pnt2d& Location() const { return pos.Location(); }
+
   //! Returns the major radius of the Ellipse.
-    Standard_Real MajorRadius() const;
-  
+  Standard_Real MajorRadius() const { return majorRadius; }
+
   //! Returns the minor radius of the Ellipse.
-    Standard_Real MinorRadius() const;
-  
+  Standard_Real MinorRadius() const { return minorRadius; }
 
   //! Returns p = (1 - e * e) * MajorRadius where e is the eccentricity
   //! of the ellipse.
   //! Returns 0 if MajorRadius = 0
-    Standard_Real Parameter() const;
-  
+  Standard_Real Parameter() const;
+
   //! Returns the major axis of the ellipse.
-    const gp_Ax22d& Axis() const;
-  
+  const gp_Ax22d& Axis() const { return pos; }
+
   //! Returns the major axis of the ellipse.
-    gp_Ax2d XAxis() const;
-  
+  gp_Ax2d XAxis() const { return pos.XAxis(); }
+
   //! Returns the minor axis of the ellipse.
   //! Reverses the direction of the circle.
-    gp_Ax2d YAxis() const;
-  
-    void Reverse();
-  
-    Standard_NODISCARD gp_Elips2d Reversed() const;
-  
+  gp_Ax2d YAxis() const { return pos.YAxis(); }
+
+  void Reverse()
+  {
+    gp_Dir2d aTemp = pos.YDirection();
+    aTemp.Reverse();
+    pos.SetAxis (gp_Ax22d (pos.Location(), pos.XDirection(), aTemp));
+  }
+
+  Standard_NODISCARD gp_Elips2d 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; }
 
-  //! Performs the symmetrical transformation of a ellipse with respect
-  //! to the point P which is the center of the symmetry
-  Standard_NODISCARD Standard_EXPORT gp_Elips2d Mirrored (const gp_Pnt2d& P) const;
-  
-  Standard_EXPORT void Mirror (const gp_Ax2d& A);
-  
+  Standard_EXPORT void Mirror (const gp_Pnt2d& theP);
 
   //! Performs the symmetrical transformation of a ellipse with respect
-  //! to an axis placement which is the axis of the symmetry.
-  Standard_NODISCARD Standard_EXPORT gp_Elips2d Mirrored (const gp_Ax2d& A) const;
-  
-  void Rotate (const gp_Pnt2d& P, const Standard_Real Ang);
-  
-  Standard_NODISCARD gp_Elips2d Rotated (const gp_Pnt2d& P, const Standard_Real Ang) const;
-  
-  void Scale (const gp_Pnt2d& P, const Standard_Real S);
-  
-
-  //! Scales a ellipse. S is the scaling value.
-  Standard_NODISCARD gp_Elips2d Scaled (const gp_Pnt2d& P, const Standard_Real S) const;
-  
-  void Transform (const gp_Trsf2d& T);
-  
+  //! to the point theP which is the center of the symmetry
+  Standard_NODISCARD Standard_EXPORT gp_Elips2d Mirrored (const gp_Pnt2d& theP) const;
 
-  //! Transforms an ellipse with the transformation T from class Trsf2d.
-  Standard_NODISCARD gp_Elips2d Transformed (const gp_Trsf2d& T) const;
-  
-  void Translate (const gp_Vec2d& V);
-  
-
-  //! Translates a ellipse in the direction of the vector V.
-  //! The magnitude of the translation is the vector's magnitude.
-  Standard_NODISCARD gp_Elips2d Translated (const gp_Vec2d& V) const;
-  
-  void Translate (const gp_Pnt2d& P1, const gp_Pnt2d& P2);
-  
+  Standard_EXPORT void Mirror (const gp_Ax2d& theA);
 
-  //! Translates a ellipse from the point P1 to the point P2.
-  Standard_NODISCARD gp_Elips2d Translated (const gp_Pnt2d& P1, const gp_Pnt2d& P2) const;
+  //! Performs the symmetrical transformation of a ellipse with respect
+  //! to an axis placement which is the axis of the symmetry.
+  Standard_NODISCARD Standard_EXPORT gp_Elips2d Mirrored (const gp_Ax2d& theA) const;
 
+  void Rotate (const gp_Pnt2d& theP, const Standard_Real theAng) { pos.Rotate (theP, theAng); }
 
+  Standard_NODISCARD gp_Elips2d Rotated (const gp_Pnt2d& theP, const Standard_Real theAng) const
+  {
+    gp_Elips2d anE = *this;
+    anE.pos.Rotate (theP, theAng);
+    return anE;
+  }
 
+  void Scale (const gp_Pnt2d& theP, const Standard_Real theS);
 
-protected:
+  //! Scales a ellipse. theS is the scaling value.
+  Standard_NODISCARD gp_Elips2d Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const;
 
+  void Transform (const gp_Trsf2d& theT);
 
+  //! Transforms an ellipse with the transformation theT from class Trsf2d.
+  Standard_NODISCARD gp_Elips2d Transformed (const gp_Trsf2d& theT) const;
 
+  void Translate (const gp_Vec2d& theV) { pos.Translate (theV); }
 
+  //! Translates a ellipse in the direction of the vector theV.
+  //! The magnitude of the translation is the vector's magnitude.
+  Standard_NODISCARD gp_Elips2d Translated (const gp_Vec2d& theV) const
+  {
+    gp_Elips2d anE = *this;
+    anE.pos.Translate (theV);
+    return anE;
+  }
+
+  void Translate (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) { pos.Translate (theP1, theP2); }
+
+  //! Translates a ellipse from the point theP1 to the point theP2.
+  Standard_NODISCARD gp_Elips2d Translated (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) const
+  {
+    gp_Elips2d anE = *this;
+    anE.pos.Translate (theP1, theP2);
+    return anE;
+  }
 
 private:
 
-
-
   gp_Ax22d pos;
   Standard_Real majorRadius;
   Standard_Real minorRadius;
 
-
 };
 
 
-#include <gp_Elips2d.lxx>
-
-
-
-
+// =======================================================================
+// function : Directrix1
+// purpose  :
+// =======================================================================
+inline gp_Ax2d gp_Elips2d::Directrix1() const
+{
+  Standard_Real anE = Eccentricity();
+  Standard_ConstructionError_Raise_if (anE <= gp::Resolution(), "gp_Elips2d::Directrix1() - zero eccentricity");
+  gp_XY anOrig = pos.XDirection().XY();
+  anOrig.Multiply (majorRadius / anE);
+  anOrig.Add (pos.Location().XY());
+  return gp_Ax2d (gp_Pnt2d (anOrig), gp_Dir2d (pos.YDirection()));
+}
+
+// =======================================================================
+// function : Directrix2
+// purpose  :
+// =======================================================================
+inline gp_Ax2d gp_Elips2d::Directrix2() const
+{
+  Standard_Real anE = Eccentricity();
+  Standard_ConstructionError_Raise_if (anE <= gp::Resolution(), "gp_Elips2d::Directrix2() - zero eccentricity");
+  gp_XY anOrig = pos.XDirection().XY();
+  anOrig.Multiply (-majorRadius / anE);
+  anOrig.Add (pos.Location().XY());
+  return gp_Ax2d (gp_Pnt2d (anOrig), gp_Dir2d (pos.YDirection()));
+}
+
+// =======================================================================
+// function : Eccentricity
+// purpose  :
+// =======================================================================
+inline Standard_Real gp_Elips2d::Eccentricity() const
+{
+  if (majorRadius == 0.0)
+  {
+    return 0.0;
+  }
+  else
+  {
+    return sqrt (majorRadius * majorRadius - minorRadius * minorRadius) / majorRadius;
+  }
+}
+
+// =======================================================================
+// function : Focus1
+// purpose  :
+// =======================================================================
+inline gp_Pnt2d gp_Elips2d::Focus1() const
+{
+  Standard_Real aC = sqrt (majorRadius * majorRadius - minorRadius * minorRadius);
+  const gp_Pnt2d& aPP = pos.Location();
+  const gp_Dir2d& aDD = pos.XDirection();
+  return gp_Pnt2d (aPP.X() + aC * aDD.X(),
+                   aPP.Y() + aC * aDD.Y());
+}
+
+// =======================================================================
+// function : Focus2
+// purpose  :
+// =======================================================================
+inline gp_Pnt2d gp_Elips2d::Focus2() const
+{
+  Standard_Real aC = sqrt (majorRadius * majorRadius - minorRadius * minorRadius);
+  const gp_Pnt2d& aPP = pos.Location();
+  const gp_Dir2d& aDD = pos.XDirection();
+  return gp_Pnt2d (aPP.X() - aC * aDD.X(),
+                   aPP.Y() - aC * aDD.Y());
+}
+
+// =======================================================================
+// function : Scale
+// purpose  :
+// =======================================================================
+inline void gp_Elips2d::Scale (const gp_Pnt2d& theP, const Standard_Real theS)
+{
+  majorRadius *= theS;
+  if (majorRadius < 0)
+  {
+    majorRadius = -majorRadius;
+  }
+  minorRadius *= theS;
+  if (minorRadius < 0)
+  {
+    minorRadius = -minorRadius;
+  }
+  pos.Scale (theP, theS);
+}
+
+// =======================================================================
+// function : Scaled
+// purpose  :
+// =======================================================================
+inline gp_Elips2d gp_Elips2d::Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const
+{
+  gp_Elips2d anE = *this;
+  anE.majorRadius *= theS;
+  if (anE.majorRadius < 0)
+  {
+    anE.majorRadius = -anE.majorRadius;
+  }
+  anE.minorRadius *= theS;
+  if (anE.minorRadius < 0)
+  {
+    anE.minorRadius = -anE.minorRadius;
+  }
+  anE.pos.Scale (theP, theS);
+  return anE; 
+}
+
+// =======================================================================
+// function : Parameter
+// purpose  :
+// =======================================================================
+inline Standard_Real gp_Elips2d::Parameter() const
+{ 
+  if (majorRadius == 0.0)
+  {
+    return 0.0;
+  }
+  else
+  {
+    return (minorRadius * minorRadius) / majorRadius;
+  }
+}
+
+// =======================================================================
+// function : Reversed
+// purpose  :
+// =======================================================================
+inline gp_Elips2d gp_Elips2d::Reversed() const
+{
+  gp_Elips2d anE = *this;
+  gp_Dir2d aTemp = pos.YDirection ();
+  aTemp.Reverse ();
+  anE.pos.SetAxis (gp_Ax22d (pos.Location(),pos.XDirection(), aTemp));
+  return anE;
+}
+
+// =======================================================================
+// function : Transform
+// purpose  :
+// =======================================================================
+inline void gp_Elips2d::Transform (const gp_Trsf2d& theT)
+{
+  Standard_Real aTSca = theT.ScaleFactor();
+  if (aTSca < 0.0)
+  {
+    aTSca = -aTSca;
+  }
+  majorRadius *=  aTSca;
+  minorRadius *=  aTSca;
+  pos.Transform (theT);
+}
+
+// =======================================================================
+// function : Transformed
+// purpose  :
+// =======================================================================
+inline gp_Elips2d gp_Elips2d::Transformed (const gp_Trsf2d& theT) const  
+{
+  gp_Elips2d anE = *this;
+  anE.majorRadius *= theT.ScaleFactor();
+  if (anE.majorRadius < 0)
+  {
+    anE.majorRadius = -anE.majorRadius;
+  }
+  anE.minorRadius *= theT.ScaleFactor();
+  if (anE.minorRadius < 0)
+  {
+    anE.minorRadius = -anE.minorRadius;
+  }
+  anE.pos.Transform (theT);
+  return anE;
+}
 
 #endif // _gp_Elips2d_HeaderFile
diff --git a/src/gp/gp_Elips2d.lxx b/src/gp/gp_Elips2d.lxx
deleted file mode 100644 (file)
index fb689fc..0000000
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp_Trsf2d.hxx>
-#include <gp.hxx>
-#include <Standard_ConstructionError.hxx>
-
-inline gp_Elips2d::gp_Elips2d() :
-majorRadius(RealLast()),
-minorRadius(RealSmall())
-{ }
-
-inline gp_Elips2d::gp_Elips2d (const gp_Ax2d& MajorAxis, 
-                              const Standard_Real MajorRadius, 
-                              const Standard_Real MinorRadius,
-                              const Standard_Boolean Sense) :  
-                              majorRadius(MajorRadius), 
-                              minorRadius(MinorRadius) 
-{ 
-  pos = gp_Ax22d(MajorAxis,Sense); 
-  Standard_ConstructionError_Raise_if (MinorRadius < 0.0 || MajorRadius < MinorRadius,
-                                       "gp_Elips2d() - invalid construction parameters");
-}
-
-inline gp_Elips2d::gp_Elips2d (const gp_Ax22d& A, 
-                              const Standard_Real MajorRadius, 
-                              const Standard_Real MinorRadius) :  
-                              pos(A), 
-                              majorRadius(MajorRadius), 
-                              minorRadius(MinorRadius) 
-{ 
-  Standard_ConstructionError_Raise_if (MinorRadius < 0.0 || MajorRadius < MinorRadius,
-                                       "gp_Elips2d() - invalid construction parameters");
-}
-
-inline void gp_Elips2d::SetLocation (const gp_Pnt2d& P)
-{  pos.SetLocation(P);}
-
-inline void gp_Elips2d::SetMajorRadius (const Standard_Real MajorRadius)
-{ 
-  Standard_ConstructionError_Raise_if (MajorRadius < minorRadius,
-                                       "gp_Elips2d::SetMajorRadius() - major radius should be greater or equal to minor radius");
-  majorRadius = MajorRadius;
-}
-
-inline void gp_Elips2d::SetMinorRadius (const Standard_Real MinorRadius)
-{ 
-  Standard_ConstructionError_Raise_if (MinorRadius < 0.0 || majorRadius < MinorRadius,
-                                       "gp_Elips2d::SetMinorRadius() - minor radius should be a positive number lesser or equal to major radius");
-  minorRadius = MinorRadius;
-}
-
-inline void gp_Elips2d::SetXAxis (const gp_Ax2d& A)
-{ pos.SetXAxis(A); }
-
-inline void gp_Elips2d::SetAxis (const gp_Ax22d& A)
-{ pos.SetAxis(A); }
-
-inline void gp_Elips2d::SetYAxis (const gp_Ax2d& A)
-{  pos.SetYAxis(A); }
-
-inline  Standard_Real gp_Elips2d::Area() const
-{ return M_PI * majorRadius * minorRadius; }
-
-inline gp_Ax2d gp_Elips2d::Directrix1() const
-{
-  Standard_Real E = Eccentricity();
-  Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "gp_Elips2d::Directrix1() - zero eccentricity");
-  gp_XY Orig = pos.XDirection().XY();
-  Orig.Multiply (majorRadius/E);
-  Orig.Add (pos.Location().XY());
-  return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
-}
-
-inline gp_Ax2d gp_Elips2d::Directrix2() const
-{
-  Standard_Real E = Eccentricity();
-  Standard_ConstructionError_Raise_if (E <= gp::Resolution(), "gp_Elips2d::Directrix2() - zero eccentricity");
-  gp_XY Orig = pos.XDirection().XY();
-  Orig.Multiply (-majorRadius/E);
-  Orig.Add (pos.Location().XY());
-  return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
-}
-
-inline Standard_Real gp_Elips2d::Eccentricity() const
-{
-  if (majorRadius == 0.0) {  return 0.0; }
-  else {
-    return sqrt(majorRadius * majorRadius - 
-               minorRadius * minorRadius) / majorRadius;
-  }
-}
-
-inline Standard_Real gp_Elips2d::Focal() const
-{
-  return 2.0 * sqrt(majorRadius * majorRadius -
-                   minorRadius * minorRadius);
-}
-
-inline gp_Pnt2d gp_Elips2d::Focus1() const
-{
-  Standard_Real C = sqrt(majorRadius * majorRadius -
-                        minorRadius * minorRadius);
-  const gp_Pnt2d& PP = pos.Location  ();
-  const gp_Dir2d& DD = pos.XDirection();
-  return gp_Pnt2d (PP.X() + C * DD.X(),
-                  PP.Y() + C * DD.Y());
-}
-
-inline gp_Pnt2d gp_Elips2d::Focus2() const
-{
-  Standard_Real C = sqrt (majorRadius * majorRadius -
-                         minorRadius * minorRadius);
-  const gp_Pnt2d& PP = pos.Location  ();
-  const gp_Dir2d& DD = pos.XDirection();
-  return gp_Pnt2d (PP.X() - C * DD.X(),
-                  PP.Y() - C * DD.Y());
-}
-
-inline const gp_Pnt2d& gp_Elips2d::Location () const
-{ return pos.Location(); }
-
-inline   Standard_Real gp_Elips2d::MajorRadius() const
-{ return majorRadius; }
-
-inline   Standard_Real gp_Elips2d::MinorRadius() const
-{ return minorRadius; }
-
-inline Standard_Real gp_Elips2d::Parameter () const
-{ 
-  if (majorRadius == 0.0) return 0.0;
-  else                    return (minorRadius * minorRadius) / majorRadius;
-}
-
-inline   const gp_Ax22d& gp_Elips2d::Axis () const
-{ return pos; }
-
-inline gp_Ax2d gp_Elips2d::YAxis () const
-{  return pos.YAxis(); }
-
-inline gp_Ax2d gp_Elips2d::XAxis () const
-{   return pos.XAxis();  }
-
-inline void gp_Elips2d::Reverse() 
-{
-  gp_Dir2d Temp = pos.YDirection ();
-  Temp.Reverse ();
-  pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
-}
-
-inline gp_Elips2d gp_Elips2d::Reversed() const
-{
-  gp_Elips2d E = *this;
-  gp_Dir2d Temp = pos.YDirection ();
-  Temp.Reverse ();
-  E.pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
-  return E;
-}
-
-inline Standard_Boolean gp_Elips2d::IsDirect() const
-{ return (pos.XDirection().Crossed(pos.YDirection())) >= 0.0; }
-
-inline void gp_Elips2d::Rotate (const gp_Pnt2d& P,
-                               const Standard_Real Ang)
-{ pos.Rotate (P, Ang); }
-
-inline gp_Elips2d gp_Elips2d::Rotated (const gp_Pnt2d& P,
-                                      const Standard_Real Ang) const  
-{
-  gp_Elips2d E = *this;
-  E.pos.Rotate (P, Ang);
-  return E; 
-}
-
-inline void gp_Elips2d::Scale (const gp_Pnt2d& P,
-                              const Standard_Real S) 
-{ 
-  majorRadius *= S;
-  if (majorRadius < 0) majorRadius = - majorRadius;
-  minorRadius *= S;
-  if (minorRadius < 0) minorRadius = - minorRadius;
-  pos.Scale(P, S);
-}
-
-inline gp_Elips2d gp_Elips2d::Scaled (const gp_Pnt2d& P,
-                                     const Standard_Real S) const  
-{
-  gp_Elips2d E = *this;
-  E.majorRadius *= S;
-  if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
-  E.minorRadius *= S;
-  if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
-  E.pos.Scale(P, S);
-  return E; 
-}
-
-inline void gp_Elips2d::Transform(const gp_Trsf2d& T)
-{
-  Standard_Real TSca = T.ScaleFactor();
-  if(TSca<0.0) TSca=-TSca;
-  majorRadius *=  TSca;
-  minorRadius *=  TSca;
-  pos.Transform(T);
-}
-
-inline gp_Elips2d gp_Elips2d::Transformed (const gp_Trsf2d& T) const  
-{
-  gp_Elips2d E = *this;
-  E.majorRadius *= T.ScaleFactor();
-  if (E.majorRadius < 0) E.majorRadius = - E.majorRadius;
-  E.minorRadius *= T.ScaleFactor();
-  if (E.minorRadius < 0) E.minorRadius = - E.minorRadius;
-  E.pos.Transform(T);
-  return E;
-}
-
-inline void gp_Elips2d::Translate (const gp_Vec2d& V)
-{ pos.Translate(V); }
-
-inline gp_Elips2d gp_Elips2d::Translated (const gp_Vec2d& V) const  
-{
-  gp_Elips2d E = *this;
-  E.pos.Translate(V);
-  return E; 
-}
-
-inline void gp_Elips2d::Translate (const gp_Pnt2d& P1,
-                                  const gp_Pnt2d& P2) 
-{ pos.Translate(P1, P2); }
-
-inline gp_Elips2d gp_Elips2d::Translated (const gp_Pnt2d& P1,
-                                         const gp_Pnt2d& P2) const  
-{
-  gp_Elips2d E = *this;
-  E.pos.Translate(P1, P2);
-  return E; 
-}
-
index 76b97fd..c69914f 100644 (file)
 
 #define No_Standard_OutOfRange
 
+#include <gp_GTrsf.hxx>
 
 #include <gp_Ax1.hxx>
 #include <gp_Ax2.hxx>
-#include <gp_GTrsf.hxx>
 #include <gp_Mat.hxx>
 #include <gp_Trsf.hxx>
 #include <gp_XYZ.hxx>
index 7bfde6c..1971143 100644 (file)
 #ifndef _gp_GTrsf_HeaderFile
 #define _gp_GTrsf_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
+#include <gp_Ax1.hxx>
+#include <gp_Ax2.hxx>
 #include <gp_Mat.hxx>
-#include <gp_XYZ.hxx>
-#include <gp_TrsfForm.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
-#include <Standard_Boolean.hxx>
 #include <gp_Trsf.hxx>
-class Standard_ConstructionError;
-class Standard_OutOfRange;
+#include <gp_TrsfForm.hxx>
+#include <gp_XYZ.hxx>
+#include <Standard_ConstructionError.hxx>
+#include <Standard_OutOfRange.hxx>
+
 class gp_Trsf;
 class gp_Mat;
-class gp_XYZ;
-class gp_Ax1;
-class gp_Ax2;
 
 // Avoid possible conflict with SetForm macro defined by windows.h
 #ifdef SetForm
@@ -70,62 +63,85 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! Returns the Identity transformation.
-    gp_GTrsf();
-  
+  gp_GTrsf()
+  {
+    shape = gp_Identity;
+    matrix.SetScale (1.0);
+    loc.SetCoord (0.0, 0.0, 0.0);
+    scale = 1.0;
+  }
 
-  //! Converts the gp_Trsf transformation T into a
+  //! Converts the gp_Trsf transformation theT into a
   //! general transformation, i.e. Returns a GTrsf with
-  //! the same matrix of coefficients as the Trsf T.
-    gp_GTrsf(const gp_Trsf& T);
-  
+  //! the same matrix of coefficients as the Trsf theT.
+  gp_GTrsf (const gp_Trsf& theT)
+  {
+    shape = theT.Form();
+    matrix = theT.matrix;
+    loc = theT.TranslationPart();
+    scale = theT.ScaleFactor();
+  }
 
-  //! Creates a transformation based on the matrix M and the
-  //! vector V where M defines the vectorial part of
+  //! Creates a transformation based on the matrix theM and the
+  //! vector theV where theM defines the vectorial part of
   //! the transformation, and V the translation part, or
-    gp_GTrsf(const gp_Mat& M, const gp_XYZ& V);
-  
-  //! Changes this transformation into an affinity of ratio Ratio
-  //! with respect to the axis A1.
+  gp_GTrsf (const gp_Mat& theM, const gp_XYZ& theV)
+  : matrix (theM),
+    loc (theV)
+  {
+    shape = gp_Other;
+    scale = 0.0;
+  }
+
+  //! Changes this transformation into an affinity of ratio theRatio
+  //! with respect to the axis theA1.
   //! Note: an affinity is a point-by-point transformation that
   //! transforms any point P into a point P' such that if H is
-  //! the orthogonal projection of P on the axis A1 or the
+  //! the orthogonal projection of P on the axis theA1 or the
   //! plane A2, the vectors HP and HP' satisfy:
-  //! HP' = Ratio * HP.
-    void SetAffinity (const gp_Ax1& A1, const Standard_Real Ratio);
-  
-  //! Changes this transformation into an affinity of ratio Ratio
+  //! HP' = theRatio * HP.
+  void SetAffinity (const gp_Ax1& theA1, const Standard_Real theRatio);
+
+  //! Changes this transformation into an affinity of ratio theRatio
   //! with respect to  the plane defined by the origin, the "X Direction" and
-  //! the "Y Direction" of coordinate system A2.
+  //! the "Y Direction" of coordinate system theA2.
   //! Note: an affinity is a point-by-point transformation that
   //! transforms any point P into a point P' such that if H is
   //! the orthogonal projection of P on the axis A1 or the
-  //! plane A2, the vectors HP and HP' satisfy:
-  //! HP' = Ratio * HP.
-    void SetAffinity (const gp_Ax2& A2, const Standard_Real Ratio);
-  
-
-  //! Replaces  the coefficient (Row, Col) of the matrix representing
-  //! this transformation by Value.  Raises OutOfRange
-  //! if  Row < 1 or Row > 3 or Col < 1 or Col > 4
-    void SetValue (const Standard_Integer Row, const Standard_Integer Col, const Standard_Real Value);
-  
-  //! Replaces the vectorial part of this transformation by Matrix.
-    void SetVectorialPart (const gp_Mat& Matrix);
-  
+  //! plane theA2, the vectors HP and HP' satisfy:
+  //! HP' = theRatio * HP.
+  void SetAffinity (const gp_Ax2& theA2, const Standard_Real theRatio);
+
+  //! Replaces  the coefficient (theRow, theCol) of the matrix representing
+  //! this transformation by theValue.  Raises OutOfRange
+  //! if  theRow < 1 or theRow > 3 or theCol < 1 or theCol > 4
+  void SetValue (const Standard_Integer theRow, const Standard_Integer theCol, const Standard_Real theValue);
+
+  //! Replaces the vectorial part of this transformation by theMatrix.
+  void SetVectorialPart (const gp_Mat& theMatrix)
+  {
+    matrix = theMatrix;
+    shape = gp_Other;
+    scale = 0.0;
+  }
+
   //! Replaces the translation part of
-  //! this transformation by the coordinates of the number triple Coord.
-  Standard_EXPORT void SetTranslationPart (const gp_XYZ& Coord);
-  
-  //! Assigns the vectorial and translation parts of T to this transformation.
-    void SetTrsf (const gp_Trsf& T);
-  
+  //! this transformation by the coordinates of the number triple theCoord.
+  Standard_EXPORT void SetTranslationPart (const gp_XYZ& theCoord);
+
+  //! Assigns the vectorial and translation parts of theT to this transformation.
+  void SetTrsf (const gp_Trsf& theT)
+  {
+    shape = theT.shape;
+    matrix = theT.matrix;
+    loc = theT.loc;
+    scale = theT.scale;
+  }
 
   //! Returns true if the determinant of the vectorial part of
   //! this transformation is negative.
-    Standard_Boolean IsNegative() const;
-  
+  Standard_Boolean IsNegative() const { return matrix.Determinant() < 0.0; }
 
   //! Returns true if this transformation is singular (and
   //! therefore, cannot be inverted).
@@ -135,16 +151,14 @@ public:
   //! than or equal to gp::Resolution().
   //! Warning
   //! If this transformation is singular, it cannot be inverted.
-    Standard_Boolean IsSingular() const;
-  
+  Standard_Boolean IsSingular() const { return matrix.IsSingular(); }
 
   //! Returns the nature of the transformation.  It can be an
   //! identity transformation, a rotation, a translation, a mirror
   //! transformation (relative to a point, an axis or a plane), a
   //! scaling transformation, a compound transformation or
   //! some other type of transformation.
-  gp_TrsfForm Form() const;
-  
+  gp_TrsfForm Form() const { return shape; }
 
   //! verify and set the shape of the GTrsf Other or CompoundTrsf
   //! Ex :
@@ -155,35 +169,34 @@ public:
   //! myGTrsf.SetForm();
   //! @endcode
   Standard_EXPORT void SetForm();
-  
+
   //! Returns the translation part of the GTrsf.
-    const gp_XYZ& TranslationPart() const;
-  
+  const gp_XYZ& TranslationPart() const { return loc; }
 
   //! Computes the vectorial part of the GTrsf. The returned Matrix
   //! is a  3*3 matrix.
-    const gp_Mat& VectorialPart() const;
-  
+  const gp_Mat& VectorialPart() const { return matrix; }
 
   //! Returns the coefficients of the global matrix of transformation.
-  //! Raises OutOfRange if Row < 1 or Row > 3 or Col < 1 or Col > 4
-    Standard_Real Value (const Standard_Integer Row, const Standard_Integer Col) const;
-  Standard_Real operator() (const Standard_Integer Row, const Standard_Integer Col) const
-{
-  return Value(Row,Col);
-}
-  
+  //! Raises OutOfRange if theRow < 1 or theRow > 3 or theCol < 1 or theCol > 4
+  Standard_Real Value (const Standard_Integer theRow, const Standard_Integer theCol) const;
+
+  Standard_Real operator() (const Standard_Integer theRow, const Standard_Integer theCol) const { return Value (theRow, theCol); }
+
   Standard_EXPORT void Invert();
-  
 
   //! Computes the reverse transformation.
   //! Raises an exception if the matrix of the transformation
   //! is not inversible.
-  Standard_NODISCARD gp_GTrsf Inverted() const;
-  
+  Standard_NODISCARD gp_GTrsf Inverted() const
+  {
+    gp_GTrsf aT = *this;
+    aT.Invert();
+    return aT;
+  }
 
-  //! Computes the transformation composed from T and <me>.
-  //! In a C++ implementation you can also write Tcomposed = <me> * T.
+  //! Computes the transformation composed from theT and <me>.
+  //! In a C++ implementation you can also write Tcomposed = <me> * theT.
   //! Example :
   //! @code
   //! gp_GTrsf T1, T2, Tcomp; ...............
@@ -197,51 +210,54 @@ public:
   //! T1.Transforms(P2);                  //using T1 then T2
   //! T2.Transforms(P2);                  // P1 = P2 !!!
   //! @endcode
-  Standard_NODISCARD gp_GTrsf Multiplied (const gp_GTrsf& T) const;
-  Standard_NODISCARD gp_GTrsf operator * (const gp_GTrsf& T)  const
-  {
-    return Multiplied(T);
+  Standard_NODISCARD gp_GTrsf Multiplied (const gp_GTrsf& theT) const
+   {
+    gp_GTrsf aTres = *this;
+    aTres.Multiply (theT);
+    return aTres;
   }
-  
 
-  //! Computes the transformation composed with <me> and T.
-  //! <me> = <me> * T
-  Standard_EXPORT void Multiply (const gp_GTrsf& T);
-  void operator *= (const gp_GTrsf& T) 
-  {
-    Multiply(T);
-  }
-  
+  Standard_NODISCARD gp_GTrsf operator * (const gp_GTrsf& theT)  const { return Multiplied (theT); }
+
+  //! Computes the transformation composed with <me> and theT.
+  //! <me> = <me> * theT
+  Standard_EXPORT void Multiply (const gp_GTrsf& theT);
 
-  //! Computes the product of the transformation T and this
+  void operator *= (const gp_GTrsf& theT) { Multiply (theT); }
+
+  //! Computes the product of the transformation theT and this
   //! transformation and assigns the result to this transformation.
-  //! this = T * this
-  Standard_EXPORT void PreMultiply (const gp_GTrsf& T);
-  
-  Standard_EXPORT void Power (const Standard_Integer N);
-  
+  //! this = theT * this
+  Standard_EXPORT void PreMultiply (const gp_GTrsf& theT);
+
+  Standard_EXPORT void Power (const Standard_Integer theN);
 
   //! Computes:
   //! -   the product of this transformation multiplied by itself
-  //! N times, if N is positive, or
+  //! theN times, if theN is positive, or
   //! -   the product of the inverse of this transformation
-  //! multiplied by itself |N| times, if N is negative.
-  //! If N equals zero, the result is equal to the Identity
+  //! multiplied by itself |theN| times, if theN is negative.
+  //! If theN equals zero, the result is equal to the Identity
   //! transformation.
-  //! I.e.:  <me> * <me> * .......* <me>, N time.
-  //! if N =0 <me> = Identity
-  //! if N < 0 <me> = <me>.Inverse() *...........* <me>.Inverse().
+  //! I.e.:  <me> * <me> * .......* <me>, theN time.
+  //! if theN =0 <me> = Identity
+  //! if theN < 0 <me> = <me>.Inverse() *...........* <me>.Inverse().
   //!
   //! Raises an exception if N < 0 and if the matrix of the
   //! transformation not inversible.
-  Standard_NODISCARD gp_GTrsf Powered (const Standard_Integer N) const;
-  
-    void Transforms (gp_XYZ& Coord) const;
-  
+  Standard_NODISCARD gp_GTrsf Powered (const Standard_Integer theN) const
+  {
+    gp_GTrsf aT = *this;
+    aT.Power (theN);
+    return aT;
+  }
+
+  void Transforms (gp_XYZ& theCoord) const;
+
   //! Transforms a triplet XYZ with a GTrsf.
-    void Transforms (Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const;
-  
-    gp_Trsf Trsf() const;
+  void Transforms (Standard_Real& theX, Standard_Real& theY, Standard_Real& theZ) const;
+
+  gp_Trsf Trsf() const;
 
   //! Convert transformation to 4x4 matrix.
   template<class T>
@@ -284,10 +300,141 @@ private:
 };
 
 
-#include <gp_GTrsf.lxx>
+//=======================================================================
+//function : SetAffinity
+// purpose :
+//=======================================================================
+inline void gp_GTrsf::SetAffinity (const gp_Ax1& theA1, const Standard_Real theRatio)
+{
+  shape = gp_Other;
+  scale = 0.0;
+  matrix.SetDot (theA1.Direction().XYZ());
+  matrix.Multiply (1.0 - theRatio);
+  matrix.SetDiagonal (matrix.Value (1,1) + theRatio,
+                      matrix.Value (2,2) + theRatio,
+                      matrix.Value (3,3) + theRatio);
+  loc = theA1.Location().XYZ();
+  loc.Reverse ();
+  loc.Multiply (matrix);
+  loc.Add (theA1.Location().XYZ());
+}
+
+//=======================================================================
+//function : SetAffinity
+// purpose :
+//=======================================================================
+inline void gp_GTrsf::SetAffinity (const gp_Ax2& theA2, const Standard_Real theRatio)
+{
+  shape = gp_Other;
+  scale = 0.0;
+  matrix.SetDot (theA2.Direction().XYZ());
+  matrix.Multiply (theRatio - 1.);
+  loc = theA2.Location().XYZ();
+  loc.Reverse ();
+  loc.Multiply (matrix);
+  matrix.SetDiagonal (matrix.Value (1,1) + 1.,
+                      matrix.Value (2,2) + 1.,
+                      matrix.Value (3,3) + 1.);
+}
+
+//=======================================================================
+//function : SetValue
+// purpose :
+//=======================================================================
+inline void gp_GTrsf::SetValue (const Standard_Integer theRow,
+                                const Standard_Integer theCol,
+                                const Standard_Real theValue)
+{
+  Standard_OutOfRange_Raise_if
+    (theRow < 1 || theRow > 3 || theCol < 1 || theCol > 4, " ");
+  if (theCol == 4)
+  {
+    loc.SetCoord (theRow, theValue);
+    if (shape == gp_Identity)
+    {
+      shape = gp_Translation;
+    }
+    return;
+  }
+  else
+  {
+    if (!(shape == gp_Other) && !(scale == 1.0))
+    {
+      matrix.Multiply (scale);
+    }
+    matrix.SetValue (theRow, theCol, theValue);
+    shape = gp_Other;
+    scale = 0.0;
+    return;
+  }
+}
 
+//=======================================================================
+//function : Value
+// purpose :
+//=======================================================================
+inline Standard_Real gp_GTrsf::Value (const Standard_Integer theRow,
+                                      const Standard_Integer theCol) const
+{
+  Standard_OutOfRange_Raise_if
+    (theRow < 1 || theRow > 3 || theCol < 1 || theCol > 4, " ");
+  if (theCol == 4)
+  {
+    return loc.Coord (theRow);
+  }
+  if (shape == gp_Other)
+  {
+    return matrix.Value (theRow, theCol);
+  }
+  return scale * matrix.Value (theRow, theCol);
+}
 
+//=======================================================================
+//function : Transforms
+// purpose :
+//=======================================================================
+inline void gp_GTrsf::Transforms (gp_XYZ& theCoord) const
+{
+  theCoord.Multiply (matrix);
+  if (!(shape == gp_Other) && !(scale == 1.0))
+  {
+    theCoord.Multiply (scale);
+  }
+  theCoord.Add (loc);
+}
 
+//=======================================================================
+//function : Transforms
+// purpose :
+//=======================================================================
+inline void gp_GTrsf::Transforms (Standard_Real& theX, Standard_Real& theY, Standard_Real& theZ) const
+{
+  gp_XYZ aTriplet (theX, theY, theZ);
+  aTriplet.Multiply (matrix);
+  if (!(shape == gp_Other) && !(scale == 1.0))
+  {
+    aTriplet.Multiply (scale);
+  }
+  aTriplet.Add (loc);
+  aTriplet.Coord (theX, theY, theZ);
+}
 
+//=======================================================================
+//function : Trsf
+// purpose :
+//=======================================================================
+inline gp_Trsf gp_GTrsf::Trsf() const
+{
+  if (Form() == gp_Other)
+  {
+    throw Standard_ConstructionError("gp_GTrsf::Trsf() - non-orthogonal GTrsf");
+  }
+  gp_Trsf aT;
+  aT.shape = shape;
+  aT.scale = scale;
+  aT.matrix = matrix;
+  aT.loc = loc;
+  return aT;
+}
 
 #endif // _gp_GTrsf_HeaderFile
diff --git a/src/gp/gp_GTrsf.lxx b/src/gp/gp_GTrsf.lxx
deleted file mode 100644 (file)
index 0091baf..0000000
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <gp_Ax2.hxx>
-#include <gp_Ax1.hxx>
-#include <Standard_OutOfRange.hxx>
-#include <Standard_ConstructionError.hxx>
-
-inline gp_GTrsf::gp_GTrsf ()
-{
-  shape = gp_Identity;
-  matrix.SetScale (1.0);
-  loc.SetCoord (0.0, 0.0, 0.0);
-  scale = 1.0;
-}
-
-inline gp_GTrsf::gp_GTrsf (const gp_Trsf& T)
-{
-  shape  = T.Form();
-  matrix = T.matrix;
-  loc    = T.TranslationPart();
-  scale  = T.ScaleFactor();
-}
-
-inline gp_GTrsf::gp_GTrsf (const gp_Mat& M,
-                          const gp_XYZ& V) : matrix(M), loc(V)
-{
-  shape = gp_Other;
-  scale = 0.0;
-}
-
-inline void gp_GTrsf::SetAffinity (const gp_Ax1& A1,
-                                  const Standard_Real Ratio)
-{
-  shape = gp_Other;
-  scale = 0.0;
-  matrix.SetDot (A1.Direction().XYZ());
-  matrix.Multiply (1.0 - Ratio);
-  matrix.SetDiagonal (matrix.Value (1,1) + Ratio,
-                      matrix.Value (2,2) + Ratio,
-                      matrix.Value (3,3) + Ratio);
-  loc = A1.Location().XYZ();
-  loc.Reverse ();
-  loc.Multiply (matrix);
-  loc.Add (A1.Location().XYZ());
-}
-
-//=======================================================================
-//function : SetAffinity
-//history  : AGV 2-05-06: Correct the implementation
-//=======================================================================
-inline void gp_GTrsf::SetAffinity (const gp_Ax2& A2,
-                                  const Standard_Real Ratio)
-{
-  shape = gp_Other;
-  scale = 0.0;
-  matrix.SetDot (A2.Direction().XYZ());
-  matrix.Multiply (Ratio - 1.);
-  loc = A2.Location().XYZ();
-  loc.Reverse ();
-  loc.Multiply (matrix);
-  matrix.SetDiagonal (matrix.Value (1,1) +1.,
-                      matrix.Value (2,2) +1.,
-                      matrix.Value (3,3) +1.);
-}
-
-inline void gp_GTrsf::SetValue (const Standard_Integer Row,
-                               const Standard_Integer Col,
-                               const Standard_Real Value)
-{
-  Standard_OutOfRange_Raise_if
-    (Row < 1 || Row > 3 || Col < 1 || Col > 4, " ");
-  if (Col == 4) {
-    loc.SetCoord (Row, Value);
-    if (shape == gp_Identity) shape = gp_Translation;
-    return;
-  }
-  else { 
-    if (!(shape == gp_Other) && !(scale == 1.0)) matrix.Multiply (scale);
-    matrix.SetValue (Row, Col, Value);
-    shape = gp_Other;
-    scale = 0.0;
-    return;
-  }
-}
-
-inline void gp_GTrsf::SetVectorialPart (const gp_Mat& Matrix)
-{ 
-  matrix = Matrix;
-  shape = gp_Other;
-  scale = 0.0;
-}
-
-inline void gp_GTrsf::SetTrsf (const gp_Trsf& T)
-{
-  shape = T.shape;
-  matrix = T.matrix;
-  loc = T.loc;
-  scale = T.scale;
-}
-
-inline Standard_Boolean gp_GTrsf::IsNegative () const
-{ return matrix.Determinant() < 0.0; }
-
-inline Standard_Boolean gp_GTrsf::IsSingular () const
-{ return matrix.IsSingular(); }
-
-inline gp_TrsfForm gp_GTrsf::Form () const
-{ return shape; }
-
-inline const gp_XYZ& gp_GTrsf::TranslationPart () const
-{ return loc; }
-
-inline const gp_Mat& gp_GTrsf::VectorialPart () const
-{ return matrix; }
-
-inline Standard_Real gp_GTrsf::Value (const Standard_Integer Row,
-                                     const Standard_Integer Col) const
-{
-  Standard_OutOfRange_Raise_if
-    (Row < 1 || Row > 3 || Col < 1 || Col > 4, " ");
-  if (Col == 4) return loc.Coord (Row);
-  if (shape == gp_Other) return matrix.Value (Row, Col);
-  return scale * matrix.Value (Row, Col);
-}
-
-inline gp_GTrsf gp_GTrsf::Inverted () const
-{
-  gp_GTrsf T = *this;
-  T.Invert ();
-  return T;
-}
-
-inline gp_GTrsf gp_GTrsf::Multiplied (const gp_GTrsf& T) const
-{
-  gp_GTrsf Tres = *this;
-  Tres.Multiply (T);
-  return Tres;
-}
-
-inline gp_GTrsf gp_GTrsf::Powered (const Standard_Integer N) const
-{
-  gp_GTrsf T = *this;
-  T.Power (N);
-  return T;
-}
-
-inline void gp_GTrsf::Transforms (gp_XYZ& Coord) const
-{
-  Coord.Multiply (matrix);
-  if (!(shape == gp_Other) && !(scale == 1.0)) Coord.Multiply (scale);
-  Coord.Add(loc);
-}
-
-inline void gp_GTrsf::Transforms (Standard_Real& X,
-                                 Standard_Real& Y,
-                                 Standard_Real& Z) const
-{
-  gp_XYZ Triplet (X, Y, Z);
-  Triplet.Multiply (matrix);
-  if (!(shape == gp_Other) && !(scale == 1.0)) Triplet.Multiply (scale); 
-  Triplet.Add(loc);
-  Triplet.Coord (X, Y, Z);
-}
-
-inline gp_Trsf gp_GTrsf::Trsf () const
-{
-  if ( Form() == gp_Other )
-    throw Standard_ConstructionError("gp_GTrsf::Trsf() - non-orthogonal GTrsf");
-
-  gp_Trsf T;
-  T.shape = shape;
-  T.scale = scale;
-  T.matrix = matrix;
-  T.loc = loc;
-  return T;
-}
-
index 87f3b02..90270fc 100644 (file)
@@ -12,9 +12,9 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <gp_GTrsf2d.hxx>
 
 #include <gp_Ax2d.hxx>
-#include <gp_GTrsf2d.hxx>
 #include <gp_Mat2d.hxx>
 #include <gp_Trsf2d.hxx>
 #include <gp_XY.hxx>
index 2497f6f..1e64f7a 100644 (file)
 #ifndef _gp_GTrsf2d_HeaderFile
 #define _gp_GTrsf2d_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
+#include <gp_Ax2d.hxx>
 #include <gp_Mat2d.hxx>
-#include <gp_XY.hxx>
 #include <gp_TrsfForm.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
-#include <Standard_Boolean.hxx>
-class Standard_ConstructionError;
-class Standard_OutOfRange;
+#include <gp_XY.hxx>
+#include <Standard_ConstructionError.hxx>
+#include <Standard_OutOfRange.hxx>
+
 class gp_Trsf2d;
 class gp_Mat2d;
-class gp_XY;
-class gp_Ax2d;
-
-
 
 //! Defines a non persistent transformation in 2D space.
 //! This transformation is a general transformation.
@@ -64,51 +55,62 @@ public:
 
   DEFINE_STANDARD_ALLOC
 
-  
   //! returns identity transformation.
-    gp_GTrsf2d();
-  
-  //! Converts the gp_Trsf2d transformation T into a
+  gp_GTrsf2d()
+  {
+    shape = gp_Identity;
+    matrix.SetScale (1.0);
+    loc.SetCoord (0.0, 0.0);
+    scale = 1.0;
+  }
+
+  //! Converts the gp_Trsf2d transformation theT into a
   //! general transformation.
-    gp_GTrsf2d(const gp_Trsf2d& T);
-  
-  //! Creates   a transformation based on the matrix M and the
-  //! vector V where M defines the vectorial part of the
-  //! transformation, and V the translation part.
-    gp_GTrsf2d(const gp_Mat2d& M, const gp_XY& V);
-  
-
-  //! Changes this transformation into an affinity of ratio Ratio
-  //! with respect to the axis A.
+  gp_GTrsf2d (const gp_Trsf2d& theT);
+
+  //! Creates   a transformation based on the matrix theM and the
+  //! vector theV where theM defines the vectorial part of the
+  //! transformation, and theV the translation part.
+  gp_GTrsf2d (const gp_Mat2d& theM, const gp_XY& theV)
+  : matrix (theM),
+    loc (theV)
+  {
+    shape = gp_Other;
+    scale = 0.0;
+  }
+
+  //! Changes this transformation into an affinity of ratio theRatio
+  //! with respect to the axis theA.
   //! Note: An affinity is a point-by-point transformation that
   //! transforms any point P into a point P' such that if H is
-  //! the orthogonal projection of P on the axis A, the vectors
-  //! HP and HP' satisfy: HP' = Ratio * HP.
-  Standard_EXPORT void SetAffinity (const gp_Ax2d& A, const Standard_Real Ratio);
-  
-
-  //! Replaces   the coefficient (Row, Col) of the matrix representing
-  //! this transformation by Value,
-  //! Raises OutOfRange if Row < 1 or Row > 2 or Col < 1 or Col > 3
-    void SetValue (const Standard_Integer Row, const Standard_Integer Col, const Standard_Real Value);
-  
+  //! the orthogonal projection of P on the axis theA, the vectors
+  //! HP and HP' satisfy: HP' = theRatio * HP.
+  Standard_EXPORT void SetAffinity (const gp_Ax2d& theA, const Standard_Real theRatio);
+
+  //! Replaces   the coefficient (theRow, theCol) of the matrix representing
+  //! this transformation by theValue,
+  //! Raises OutOfRange if theRow < 1 or theRow > 2 or theCol < 1 or theCol > 3
+  void SetValue (const Standard_Integer theRow, const Standard_Integer theCol, const Standard_Real theValue);
+
   //! Replaces the translation part of this
-  //! transformation by the coordinates of the number pair Coord.
-  Standard_EXPORT void SetTranslationPart (const gp_XY& Coord);
-  
+  //! transformation by the coordinates of the number pair theCoord.
+  Standard_EXPORT void SetTranslationPart (const gp_XY& theCoord);
 
-  //! Assigns the vectorial and translation parts of T to this transformation.
-    void SetTrsf2d (const gp_Trsf2d& T);
-  
+  //! Assigns the vectorial and translation parts of theT to this transformation.
+  void SetTrsf2d (const gp_Trsf2d& theT);
 
-  //! Replaces the vectorial part of this transformation by Matrix.
-    void SetVectorialPart (const gp_Mat2d& Matrix);
-  
+  //! Replaces the vectorial part of this transformation by theMatrix.
+  void SetVectorialPart (const gp_Mat2d& theMatrix)
+  {
+    matrix = theMatrix;
+    shape = gp_Other;
+    scale = 0.0;
+  }