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

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