[occt.git] / src / gp / gp_Hypr2d.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.

// LPA et JCV 07/92 mise a jour des methodes inline pour passage sur C1

#include <gp.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_ConstructionError.hxx>

inline gp_Hypr2d::gp_Hypr2d () :
majorRadius(RealLast()),
minorRadius(RealLast())
{ }

inline gp_Hypr2d::gp_Hypr2d (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 < 0.0,"");
}

inline gp_Hypr2d::gp_Hypr2d (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 < 0.0,"");
}

inline void gp_Hypr2d::SetLocation (const gp_Pnt2d& P)
{ pos.SetLocation (P); }

inline void gp_Hypr2d::SetMajorRadius (const Standard_Real MajorRadius) 
{   
  Standard_ConstructionError_Raise_if(MajorRadius < 0.0,"");
  majorRadius = MajorRadius;
}

inline void gp_Hypr2d::SetMinorRadius (const Standard_Real MinorRadius) 
{ 
  Standard_ConstructionError_Raise_if(MinorRadius < 0.0,"");
  minorRadius = MinorRadius;
}

inline void gp_Hypr2d::SetAxis (const gp_Ax22d& A) 
{ pos.SetAxis(A); }

inline void gp_Hypr2d::SetXAxis (const gp_Ax2d& A) 
{ pos.SetXAxis(A); }

inline void gp_Hypr2d::SetYAxis (const gp_Ax2d& A) 
{ pos.SetYAxis(A); }

inline gp_Ax2d gp_Hypr2d::Asymptote1() const 
{
  Standard_ConstructionError_Raise_if (majorRadius <= gp::Resolution(), "");
  gp_Dir2d Vdir = pos.XDirection();
  gp_XY Coord1 (pos.YDirection().XY());
  gp_XY Coord2 = Coord1.Multiplied (minorRadius / majorRadius);
  Coord1.Add (Coord2);
  Vdir.SetXY (Coord1);
  return gp_Ax2d (pos.Location(), Vdir);
}

inline gp_Ax2d gp_Hypr2d::Asymptote2() const {
  Standard_ConstructionError_Raise_if (majorRadius <= gp::Resolution(), "");
  gp_Vec2d Vdir = pos.XDirection();
  gp_XY  Coord1 (pos.YDirection().XY());
  gp_XY  Coord2 = Coord1.Multiplied (-minorRadius / majorRadius);
  Coord1.Add (Coord2);
  Vdir.SetXY (Coord1);
  return gp_Ax2d (pos.Location(), Vdir);
}

inline gp_Hypr2d gp_Hypr2d::ConjugateBranch1() const 
{
  gp_Dir2d V (pos.YDirection());
  Standard_Boolean sign = (pos.XDirection().Crossed(pos.YDirection())) >= 0.0;
  return gp_Hypr2d (gp_Ax2d (pos.Location(),V), minorRadius, majorRadius,sign);
}

inline gp_Hypr2d gp_Hypr2d::ConjugateBranch2() const 
{
  gp_Dir2d V (pos.YDirection().Reversed());
  Standard_Boolean sign = (pos.XDirection().Crossed(pos.YDirection())) >= 0.0;
  return gp_Hypr2d (gp_Ax2d(pos.Location(),V),minorRadius, majorRadius,sign);
}

inline gp_Ax2d gp_Hypr2d::Directrix1() const 
{
  Standard_Real E = 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_Hypr2d::Directrix2() const
{
  Standard_Real E = Eccentricity();
  gp_XY Orig = pos.XDirection().XY();
  Orig.Multiply (Parameter()/E);
  Orig.Add (Focus1().XY());
  return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
}

inline Standard_Real gp_Hypr2d::Eccentricity() const 
{
  Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(), "");
  return sqrt(majorRadius * majorRadius +
	      minorRadius * minorRadius) / majorRadius;
}

inline Standard_Real gp_Hypr2d::Focal() const 
{
  return 2.0 * sqrt (majorRadius * majorRadius +
		     minorRadius * minorRadius);
}

inline gp_Pnt2d gp_Hypr2d::Focus1() const 
{
  Standard_Real C = sqrt (majorRadius * majorRadius +
			  minorRadius * minorRadius);
  return gp_Pnt2d (pos.Location().X() + C * pos.XDirection().X(),
		   pos.Location().Y() + C * pos.XDirection().Y());
}

inline gp_Pnt2d gp_Hypr2d::Focus2() const 
{
  Standard_Real C = sqrt (majorRadius * majorRadius +
			  minorRadius * minorRadius);
  return gp_Pnt2d (pos.Location().X() - C * pos.XDirection().X(),
		   pos.Location().Y() - C * pos.XDirection().Y());
}

inline const gp_Pnt2d& gp_Hypr2d::Location () const
{ return pos.Location(); }

inline   Standard_Real gp_Hypr2d::MajorRadius() const
 { return majorRadius; }

inline   Standard_Real gp_Hypr2d::MinorRadius() const
 { return minorRadius; }

inline gp_Hypr2d gp_Hypr2d::OtherBranch() const 
{
  Standard_Boolean sign = (pos.XDirection().Crossed(pos.YDirection())) >= 0.0;
  return gp_Hypr2d (gp_Ax2d (pos.Location(),pos.XDirection().Reversed()),
		    majorRadius,minorRadius,sign);
}

inline Standard_Real gp_Hypr2d::Parameter() const 
{ 
  Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(), "");
  return (minorRadius * minorRadius) / majorRadius;
}

inline   const gp_Ax22d& gp_Hypr2d::Axis () const
 { return pos; }

inline gp_Ax2d gp_Hypr2d::XAxis () const 
{ return pos.XAxis(); }

inline gp_Ax2d gp_Hypr2d::YAxis () const 
{ return pos.YAxis(); }

inline void gp_Hypr2d::Reverse() 
{
  gp_Dir2d Temp = pos.YDirection ();
  Temp.Reverse ();
  pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
}

inline gp_Hypr2d gp_Hypr2d::Reversed() const
{
  gp_Hypr2d H = *this;
  gp_Dir2d Temp = pos.YDirection ();
  Temp.Reverse ();
  H.pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
  return H;
}

inline Standard_Boolean gp_Hypr2d::IsDirect() const
{ return (pos.XDirection().Crossed(pos.YDirection())) >= 0.0; }

inline void gp_Hypr2d::Rotate (const gp_Pnt2d& P,
			       const Standard_Real Ang)
{pos.Rotate (P,Ang);}

inline gp_Hypr2d gp_Hypr2d::Rotated (const gp_Pnt2d& P,
				     const Standard_Real Ang) const
{
  gp_Hypr2d H = *this;
  H.pos.Rotate (P, Ang);
  return H; 
}

inline void gp_Hypr2d::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_Hypr2d gp_Hypr2d::Scaled (const gp_Pnt2d& P,
				    const Standard_Real S) const
{
  gp_Hypr2d H = *this;
  H.majorRadius *= S;
  if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
  H.minorRadius *= S;
  if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
  H.pos.Scale(P, S);
  return H; 
}

inline void gp_Hypr2d::Transform (const gp_Trsf2d& T)
{
  majorRadius *= T.ScaleFactor();
  if (majorRadius < 0) majorRadius = - majorRadius;
  minorRadius *= T.ScaleFactor();
  if (minorRadius < 0) minorRadius = - minorRadius;
  pos.Transform(T);
}

inline gp_Hypr2d gp_Hypr2d::Transformed (const gp_Trsf2d& T) const
{
gp_Hypr2d H = *this;
H.majorRadius *= T.ScaleFactor();
if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
H.minorRadius *= T.ScaleFactor();
if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
H.pos.Transform(T);
return H;
}

inline void gp_Hypr2d::Translate (const gp_Vec2d& V)
{ pos.Translate(V); }

inline gp_Hypr2d gp_Hypr2d::Translated (const gp_Vec2d& V) const
{
  gp_Hypr2d H = *this;
  H.pos.Translate(V);
  return H; 
}

inline void gp_Hypr2d::Translate (const gp_Pnt2d& P1,
				  const gp_Pnt2d& P2)
{
  pos.Translate(P1, P2);
}

inline gp_Hypr2d gp_Hypr2d::Translated (const gp_Pnt2d& P1,
					const gp_Pnt2d& P2) const
{
  gp_Hypr2d H = *this;
  H.pos.Translate(P1, P2);
  return H; 
}
Commit	Line	Data
b311480e	1	// Copyright (c) 1995-1999 Matra Datavision
	2	// Copyright (c) 1999-2012 OPEN CASCADE SAS
	3	//
	4	// The content of this file is subject to the Open CASCADE Technology Public
	5	// License Version 6.5 (the "License"). You may not use the content of this file
	6	// except in compliance with the License. Please obtain a copy of the License
	7	// at http://www.opencascade.org and read it completely before using this file.
	8	//
	9	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	10	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	11	//
	12	// The Original Code and all software distributed under the License is
	13	// distributed on an "AS IS" basis, without warranty of any kind, and the
	14	// Initial Developer hereby disclaims all such warranties, including without
	15	// limitation, any warranties of merchantability, fitness for a particular
	16	// purpose or non-infringement. Please see the License for the specific terms
	17	// and conditions governing the rights and limitations under the License.
	18
7fd59977	19	// LPA et JCV 07/92 mise a jour des methodes inline pour passage sur C1
	20
	21	#include <gp.hxx>
	22	#include <Standard_DomainError.hxx>
	23	#include <Standard_ConstructionError.hxx>
	24
	25	inline gp_Hypr2d::gp_Hypr2d () :
	26	majorRadius(RealLast()),
	27	minorRadius(RealLast())
	28	{ }
	29
	30	inline gp_Hypr2d::gp_Hypr2d (const gp_Ax22d& A,
	31	const Standard_Real MajorRadius,
	32	const Standard_Real MinorRadius) :
	33	pos(A),
	34	majorRadius(MajorRadius),
	35	minorRadius(MinorRadius)
	36	{
	37	Standard_ConstructionError_Raise_if
	38	(MinorRadius < 0.0 \|\| MajorRadius < 0.0,"");
	39	}
	40
	41	inline gp_Hypr2d::gp_Hypr2d (const gp_Ax2d& MajorAxis,
	42	const Standard_Real MajorRadius,
	43	const Standard_Real MinorRadius,
	44	const Standard_Boolean Sense) :
	45	majorRadius(MajorRadius),
	46	minorRadius(MinorRadius)
	47	{
	48	pos = gp_Ax22d(MajorAxis,Sense);
	49	Standard_ConstructionError_Raise_if
	50	(MinorRadius < 0.0 \|\| MajorRadius < 0.0,"");
	51	}
	52
	53	inline void gp_Hypr2d::SetLocation (const gp_Pnt2d& P)
	54	{ pos.SetLocation (P); }
	55
	56	inline void gp_Hypr2d::SetMajorRadius (const Standard_Real MajorRadius)
	57	{
	58	Standard_ConstructionError_Raise_if(MajorRadius < 0.0,"");
	59	majorRadius = MajorRadius;
	60	}
	61
	62	inline void gp_Hypr2d::SetMinorRadius (const Standard_Real MinorRadius)
	63	{
	64	Standard_ConstructionError_Raise_if(MinorRadius < 0.0,"");
	65	minorRadius = MinorRadius;
	66	}
	67
	68	inline void gp_Hypr2d::SetAxis (const gp_Ax22d& A)
	69	{ pos.SetAxis(A); }
	70
	71	inline void gp_Hypr2d::SetXAxis (const gp_Ax2d& A)
	72	{ pos.SetXAxis(A); }
	73
	74	inline void gp_Hypr2d::SetYAxis (const gp_Ax2d& A)
	75	{ pos.SetYAxis(A); }
	76
	77	inline gp_Ax2d gp_Hypr2d::Asymptote1() const
	78	{
	79	Standard_ConstructionError_Raise_if (majorRadius <= gp::Resolution(), "");
	80	gp_Dir2d Vdir = pos.XDirection();
	81	gp_XY Coord1 (pos.YDirection().XY());
	82	gp_XY Coord2 = Coord1.Multiplied (minorRadius / majorRadius);
83	Coord1.Add (Coord2);
84	Vdir.SetXY (Coord1);
85	return gp_Ax2d (pos.Location(), Vdir);
86	}
87
88	inline gp_Ax2d gp_Hypr2d::Asymptote2() const {
89	Standard_ConstructionError_Raise_if (majorRadius <= gp::Resolution(), "");
90	gp_Vec2d Vdir = pos.XDirection();
91	gp_XY Coord1 (pos.YDirection().XY());
92	gp_XY Coord2 = Coord1.Multiplied (-minorRadius / majorRadius);
93	Coord1.Add (Coord2);
94	Vdir.SetXY (Coord1);
95	return gp_Ax2d (pos.Location(), Vdir);
96	}
97
98	inline gp_Hypr2d gp_Hypr2d::ConjugateBranch1() const
99	{
100	gp_Dir2d V (pos.YDirection());
101	Standard_Boolean sign = (pos.XDirection().Crossed(pos.YDirection())) >= 0.0;
102	return gp_Hypr2d (gp_Ax2d (pos.Location(),V), minorRadius, majorRadius,sign);
103	}
104
105	inline gp_Hypr2d gp_Hypr2d::ConjugateBranch2() const
106	{
107	gp_Dir2d V (pos.YDirection().Reversed());
108	Standard_Boolean sign = (pos.XDirection().Crossed(pos.YDirection())) >= 0.0;
109	return gp_Hypr2d (gp_Ax2d(pos.Location(),V),minorRadius, majorRadius,sign);
110	}
111
112	inline gp_Ax2d gp_Hypr2d::Directrix1() const
113	{
114	Standard_Real E = Eccentricity();
115	gp_XY Orig = pos.XDirection().XY();
116	Orig.Multiply (majorRadius/E);
117	Orig.Add (pos.Location().XY());
118	return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
119	}
120
121	inline gp_Ax2d gp_Hypr2d::Directrix2() const
122	{
123	Standard_Real E = Eccentricity();
124	gp_XY Orig = pos.XDirection().XY();
125	Orig.Multiply (Parameter()/E);
126	Orig.Add (Focus1().XY());
127	return gp_Ax2d (gp_Pnt2d(Orig),gp_Dir2d (pos.YDirection()));
128	}
129
130	inline Standard_Real gp_Hypr2d::Eccentricity() const
131	{
132	Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(), "");
133	return sqrt(majorRadius * majorRadius +
134	minorRadius * minorRadius) / majorRadius;
135	}
136
137	inline Standard_Real gp_Hypr2d::Focal() const
138	{
139	return 2.0 * sqrt (majorRadius * majorRadius +
140	minorRadius * minorRadius);
141	}
142
143	inline gp_Pnt2d gp_Hypr2d::Focus1() const
144	{
145	Standard_Real C = sqrt (majorRadius * majorRadius +
146	minorRadius * minorRadius);
147	return gp_Pnt2d (pos.Location().X() + C * pos.XDirection().X(),
148	pos.Location().Y() + C * pos.XDirection().Y());
149	}
150
151	inline gp_Pnt2d gp_Hypr2d::Focus2() const
152	{
153	Standard_Real C = sqrt (majorRadius * majorRadius +
154	minorRadius * minorRadius);
155	return gp_Pnt2d (pos.Location().X() - C * pos.XDirection().X(),
156	pos.Location().Y() - C * pos.XDirection().Y());
157	}
158
159	inline const gp_Pnt2d& gp_Hypr2d::Location () const
160	{ return pos.Location(); }
161
162	inline Standard_Real gp_Hypr2d::MajorRadius() const
163	{ return majorRadius; }
164
165	inline Standard_Real gp_Hypr2d::MinorRadius() const
166	{ return minorRadius; }
167
168	inline gp_Hypr2d gp_Hypr2d::OtherBranch() const
169	{
170	Standard_Boolean sign = (pos.XDirection().Crossed(pos.YDirection())) >= 0.0;
171	return gp_Hypr2d (gp_Ax2d (pos.Location(),pos.XDirection().Reversed()),
172	majorRadius,minorRadius,sign);
173	}
174
175	inline Standard_Real gp_Hypr2d::Parameter() const
176	{
177	Standard_DomainError_Raise_if (majorRadius <= gp::Resolution(), "");
178	return (minorRadius * minorRadius) / majorRadius;
179	}
180
181	inline const gp_Ax22d& gp_Hypr2d::Axis () const
182	{ return pos; }
183
184	inline gp_Ax2d gp_Hypr2d::XAxis () const
185	{ return pos.XAxis(); }
186
187	inline gp_Ax2d gp_Hypr2d::YAxis () const
188	{ return pos.YAxis(); }
189
190	inline void gp_Hypr2d::Reverse()
191	{
192	gp_Dir2d Temp = pos.YDirection ();
193	Temp.Reverse ();
194	pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
195	}
196
197	inline gp_Hypr2d gp_Hypr2d::Reversed() const
198	{
199	gp_Hypr2d H = *this;
200	gp_Dir2d Temp = pos.YDirection ();
201	Temp.Reverse ();
202	H.pos.SetAxis(gp_Ax22d(pos.Location(),pos.XDirection(),Temp));
203	return H;
204	}
205
206	inline Standard_Boolean gp_Hypr2d::IsDirect() const
207	{ return (pos.XDirection().Crossed(pos.YDirection())) >= 0.0; }
208
209	inline void gp_Hypr2d::Rotate (const gp_Pnt2d& P,
210	const Standard_Real Ang)
211	{pos.Rotate (P,Ang);}
212
213	inline gp_Hypr2d gp_Hypr2d::Rotated (const gp_Pnt2d& P,
214	const Standard_Real Ang) const
215	{
216	gp_Hypr2d H = *this;
217	H.pos.Rotate (P, Ang);
218	return H;
219	}
220
221	inline void gp_Hypr2d::Scale (const gp_Pnt2d& P,
222	const Standard_Real S)
223	{
224	majorRadius *= S;
225	if (majorRadius < 0) majorRadius = - majorRadius;
226	minorRadius *= S;
227	if (minorRadius < 0) minorRadius = - minorRadius;
228	pos.Scale(P, S);
229	}
230
231	inline gp_Hypr2d gp_Hypr2d::Scaled (const gp_Pnt2d& P,
232	const Standard_Real S) const
233	{
234	gp_Hypr2d H = *this;
235	H.majorRadius *= S;
236	if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
237	H.minorRadius *= S;
238	if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
239	H.pos.Scale(P, S);
240	return H;
241	}
242
243	inline void gp_Hypr2d::Transform (const gp_Trsf2d& T)
244	{
245	majorRadius *= T.ScaleFactor();
246	if (majorRadius < 0) majorRadius = - majorRadius;
247	minorRadius *= T.ScaleFactor();
248	if (minorRadius < 0) minorRadius = - minorRadius;
249	pos.Transform(T);
250	}
251
252	inline gp_Hypr2d gp_Hypr2d::Transformed (const gp_Trsf2d& T) const
253	{
254	gp_Hypr2d H = *this;
255	H.majorRadius *= T.ScaleFactor();
256	if (H.majorRadius < 0) H.majorRadius = - H.majorRadius;
257	H.minorRadius *= T.ScaleFactor();
258	if (H.minorRadius < 0) H.minorRadius = - H.minorRadius;
259	H.pos.Transform(T);
260	return H;
261	}
262
263	inline void gp_Hypr2d::Translate (const gp_Vec2d& V)
264	{ pos.Translate(V); }
265
266	inline gp_Hypr2d gp_Hypr2d::Translated (const gp_Vec2d& V) const
267	{
268	gp_Hypr2d H = *this;
269	H.pos.Translate(V);
270	return H;
271	}
272
273	inline void gp_Hypr2d::Translate (const gp_Pnt2d& P1,
274	const gp_Pnt2d& P2)
275	{
276	pos.Translate(P1, P2);
277	}
278
279	inline gp_Hypr2d gp_Hypr2d::Translated (const gp_Pnt2d& P1,
280	const gp_Pnt2d& P2) const
281	{
282	gp_Hypr2d H = *this;
283	H.pos.Translate(P1, P2);
284	return H;
285	}
286