0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_GTrsf2d.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;
+  }
 
   //! 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).
   //! Note: The Gauss LU decomposition is used to invert the
@@ -117,44 +119,42 @@ 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 or axis), a scaling
   //! transformation, a compound transformation or some
   //! other type of transformation.
-    gp_TrsfForm Form() const;
-  
+  gp_TrsfForm Form() const { return shape; }
+
   //! Returns the translation part of the GTrsf2d.
-    const gp_XY& TranslationPart() const;
-  
+  const gp_XY& TranslationPart() const { return loc; }
 
   //! Computes the vectorial part of the GTrsf2d. The returned
   //! Matrix is a 2*2 matrix.
-    const gp_Mat2d& VectorialPart() const;
-  
+  const gp_Mat2d& VectorialPart() const { return matrix; }
 
   //! Returns the coefficients of the global matrix of transformation.
-  //! Raised OutOfRange if Row < 1 or Row > 2 or Col < 1 or Col > 3
-    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);
-}
-  
+  //! Raised OutOfRange if theRow < 1 or theRow > 2 or theCol < 1 or theCol > 3
+  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.
   //! Raised an exception if the matrix of the transformation
   //! is not inversible.
-  Standard_NODISCARD gp_GTrsf2d Inverted() const;
-  
-
-  //! Computes the transformation composed with T and <me>.
-  //! In a C++ implementation you can also write Tcomposed = <me> * T.
+  Standard_NODISCARD gp_GTrsf2d Inverted() const
+  {
+    gp_GTrsf2d aT = *this;
+    aT.Invert();
+    return aT;
+  }
+
+  //! Computes the transformation composed with theT and <me>.
+  //! In a C++ implementation you can also write Tcomposed = <me> * theT.
   //! Example :
   //! @code
   //! gp_GTrsf2d T1, T2, Tcomp; ...............
@@ -168,50 +168,57 @@ public:
   //! T1.Transforms(P2);                  //using T1 then T2
   //! T2.Transforms(P2);                  // P1 = P2 !!!
   //! @endcode
-  Standard_NODISCARD gp_GTrsf2d Multiplied (const gp_GTrsf2d& T) const;
-  Standard_NODISCARD gp_GTrsf2d operator * (const gp_GTrsf2d& T) const
-{
-  return Multiplied(T);
-}
-  
-  Standard_EXPORT void Multiply (const gp_GTrsf2d& T);
-void operator *= (const gp_GTrsf2d& T)
-{
-  Multiply(T);
-}
-  
+  Standard_NODISCARD gp_GTrsf2d Multiplied (const gp_GTrsf2d& theT) const
+  {
+    gp_GTrsf2d aTres = *this;
+    aTres.Multiply (theT);
+    return aTres;
+  }
+
+  Standard_NODISCARD gp_GTrsf2d operator * (const gp_GTrsf2d& theT) const { return Multiplied (theT); }
+
+  Standard_EXPORT void Multiply (const gp_GTrsf2d& theT);
 
-  //! Computes the product of the transformation T and this
+  void operator *= (const gp_GTrsf2d& 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_GTrsf2d& T);
-  
-  Standard_EXPORT void Power (const Standard_Integer N);
-  
+  //! this = theT * this
+  Standard_EXPORT void PreMultiply (const gp_GTrsf2d& theT);
+
+  Standard_EXPORT void Power (const Standard_Integer theN);
 
   //! Computes the following composition of transformations
-  //! <me> * <me> * .......* <me>, N time.
-  //! if N = 0 <me> = Identity
-  //! if N < 0 <me> = <me>.Inverse() *...........* <me>.Inverse().
+  //! <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
+  //! Raises an exception if theN < 0 and if the matrix of the
   //! transformation is not inversible.
-  Standard_NODISCARD gp_GTrsf2d Powered (const Standard_Integer N) const;
-  
-    void Transforms (gp_XY& Coord) const;
-  
-    Standard_NODISCARD gp_XY Transformed (const gp_XY& Coord) const;
-  
+  Standard_NODISCARD gp_GTrsf2d Powered (const Standard_Integer theN) const
+  {
+    gp_GTrsf2d aT = *this;
+    aT.Power (theN);
+    return aT;
+  }
+
+  void Transforms (gp_XY& theCoord) const;
+
+  Standard_NODISCARD gp_XY Transformed (const gp_XY& theCoord) const
+  {
+    gp_XY aNewCoord = theCoord;
+    Transforms (aNewCoord);
+    return aNewCoord;
+  }
 
   //! Applies this transformation to the coordinates:
   //! -   of the number pair Coord, or
   //! -   X and Y.
   //!
   //! Note:
-  //! -   Transforms modifies X, Y, or the coordinate pair Coord, while
+  //! -   Transforms modifies theX, theY, or the coordinate pair Coord, while
   //! -   Transformed creates a new coordinate pair.
-    void Transforms (Standard_Real& X, Standard_Real& Y) const;
-  
+  void Transforms (Standard_Real& theX, Standard_Real& theY) const;
 
   //! Converts this transformation into a gp_Trsf2d transformation.
   //! Exceptions
@@ -219,32 +226,111 @@ void operator *= (const gp_GTrsf2d& T)
   //! cannot be converted, i.e. if its form is gp_Other.
   Standard_EXPORT gp_Trsf2d Trsf2d() const;
 
-
-
-
-protected:
-
-
-
-
-
 private:
 
-
-
   gp_Mat2d matrix;
   gp_XY loc;
   gp_TrsfForm shape;
   Standard_Real scale;
 
-
 };
 
+#include <gp_Trsf2d.hxx>
 
-#include <gp_GTrsf2d.lxx>
+//=======================================================================
+//function : SetTrsf2d
+// purpose :
+//=======================================================================
+inline void gp_GTrsf2d::SetTrsf2d (const gp_Trsf2d& theT)
+{
+  shape = theT.shape;
+  matrix = theT.matrix;
+  loc = theT.loc;
+  scale = theT.scale;
+}
 
+//=======================================================================
+//function : gp_GTrsf2d
+// purpose :
+//=======================================================================
+inline gp_GTrsf2d::gp_GTrsf2d (const gp_Trsf2d& theT)
+{
+  shape = theT.shape;
+  matrix = theT.matrix;
+  loc = theT.loc;
+  scale = theT.scale;
+}
 
+//=======================================================================
+//function : SetValue
+// purpose :
+//=======================================================================
+inline void gp_GTrsf2d::SetValue (const Standard_Integer theRow,
+                                  const Standard_Integer theCol,
+                                  const Standard_Real theValue)
+{
+  Standard_OutOfRange_Raise_if
+    (theRow < 1 || theRow > 2 || theCol < 1 || theCol > 3, " ");
+  if (theCol == 3)
+  {
+    loc.SetCoord (theRow, theValue);
+  }
+  else
+  {
+    matrix.SetValue (theRow, theCol, theValue);
+  }
+  shape = gp_Other;
+}
 
+//=======================================================================
+//function : Value
+// purpose :
+//=======================================================================
+inline Standard_Real gp_GTrsf2d::Value (const Standard_Integer theRow,
+                                        const Standard_Integer theCol) const
+{
+  Standard_OutOfRange_Raise_if
+    (theRow < 1 || theRow > 2 || theCol < 1 || theCol > 3, " ");
+  if (theCol == 3)
+  {
+    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_GTrsf2d::Transforms (gp_XY& theCoord) const
+{
+  theCoord.Multiply (matrix);
+  if (!(shape == gp_Other) && !(scale == 1.0))
+  {
+    theCoord.Multiply (scale);
+  }
+  theCoord.Add (loc);
+}
+
+//=======================================================================
+//function : Transforms
+// purpose :
+//=======================================================================
+inline void gp_GTrsf2d::Transforms (Standard_Real& theX,
+                                    Standard_Real& theY) const
+{
+  gp_XY aDoublet(theX, theY);
+  aDoublet.Multiply (matrix);
+  if (!(shape == gp_Other) && !(scale == 1.0))
+  {
+    aDoublet.Multiply (scale);
+  }
+  aDoublet.Add (loc);
+  aDoublet.Coord (theX, theY);
+}
 
 #endif // _gp_GTrsf2d_HeaderFile