0024157: Parallelization of assembly part of BO

[occt.git] / src / gp / gp_Elips2d.lxx

// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.


#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,"");
}

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,"");
}

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,"");
  majorRadius = MajorRadius;
}

inline void gp_Elips2d::SetMinorRadius (const Standard_Real MinorRadius)
{ 
  Standard_ConstructionError_Raise_if
    (MinorRadius < 0.0 || majorRadius < MinorRadius,"");
  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_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_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; 
}