0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_Lin2d.hxx
1 // Copyright (c) 1991-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
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.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifndef _gp_Lin2d_HeaderFile
16 #define _gp_Lin2d_HeaderFile
17
18 #include <gp_Ax2d.hxx>
19
20 //! Describes a line in 2D space.
21 //! A line is positioned in the plane with an axis (a gp_Ax2d
22 //! object) which gives the line its origin and unit vector. A
23 //! line and an axis are similar objects, thus, we can convert
24 //! one into the other.
25 //! A line provides direct access to the majority of the edit
26 //! and query functions available on its positioning axis. In
27 //! addition, however, a line has specific functions for
28 //! computing distances and positions.
29 //! See Also
30 //! GccAna and Geom2dGcc packages which provide
31 //! functions for constructing lines defined by geometric
32 //! constraints
33 //! gce_MakeLin2d which provides functions for more
34 //! complex line constructions
35 //! Geom2d_Line which provides additional functions for
36 //! constructing lines and works, in particular, with the
37 //! parametric equations of lines
38 class gp_Lin2d 
39 {
40 public:
41
42   DEFINE_STANDARD_ALLOC
43
44   //! Creates a Line corresponding to X axis of the
45   //! reference coordinate system.
46   gp_Lin2d() {}
47
48   //! Creates a line located with theA.
49   gp_Lin2d (const gp_Ax2d& theA)
50   : pos (theA)
51   {}
52
53   //! <theP> is the location point (origin) of the line and
54   //! <theV> is the direction of the line.
55   gp_Lin2d (const gp_Pnt2d& theP, const gp_Dir2d& theV)
56   : pos (theP, theV)
57   {}
58
59   //! Creates the line from the equation theA*X + theB*Y + theC = 0.0 Raises ConstructionError if Sqrt(theA*theA + theB*theB) <= Resolution from gp.
60   //! Raised if Sqrt(theA*theA + theB*theB) <= Resolution from gp.
61   Standard_EXPORT gp_Lin2d (const Standard_Real theA, const Standard_Real theB, const Standard_Real theC);
62
63   void Reverse() { pos.Reverse(); }
64
65   //! Reverses the positioning axis of this line.
66   //! Note:
67   //! -   Reverse assigns the result to this line, while
68   //! -   Reversed creates a new one.
69   Standard_NODISCARD gp_Lin2d Reversed() const
70   {
71     gp_Lin2d aL = *this;
72     aL.pos.Reverse();
73     return aL;
74   }
75
76   //! Changes the direction of the line.
77   void SetDirection (const gp_Dir2d& theV) { pos.SetDirection (theV); }
78
79   //! Changes the origin of the line.
80   void SetLocation (const gp_Pnt2d& theP) { pos.SetLocation (theP); }
81
82   //! Complete redefinition of the line.
83   //! The "Location" point of <theA> is the origin of the line.
84   //! The "Direction" of <theA> is  the direction of the line.
85   void SetPosition (const gp_Ax2d& theA) { pos = theA; }
86
87   //! Returns the normalized coefficients of the line :
88   //! theA * X + theB * Y + theC = 0.
89   void Coefficients (Standard_Real& theA, Standard_Real& theB, Standard_Real& theC) const
90   {
91     theA = pos.Direction().Y();
92     theB = -pos.Direction().X();
93     theC = -(theA * pos.Location().X() + theB * pos.Location().Y());
94   }
95
96   //! Returns the direction of the line.
97   const gp_Dir2d& Direction() const { return pos.Direction(); }
98
99   //! Returns the location point (origin) of the line.
100   const gp_Pnt2d& Location() const { return pos.Location(); }
101
102   //! Returns the axis placement one axis with the same
103   //! location and direction as <me>.
104   const gp_Ax2d& Position() const { return pos; }
105
106   //! Computes the angle between two lines in radians.
107   Standard_Real Angle (const gp_Lin2d& theOther) const
108   {
109     return pos.Direction().Angle (theOther.pos.Direction());
110   }
111
112   //! Returns true if this line contains the point theP, that is, if the
113   //! distance between point theP and this line is less than or
114   //! equal to theLinearTolerance.
115   Standard_Boolean Contains (const gp_Pnt2d& theP, const Standard_Real theLinearTolerance) const
116   {
117     return Distance (theP) <= theLinearTolerance;
118   }
119
120   //! Computes the distance between <me> and the point <theP>.
121   Standard_Real Distance (const gp_Pnt2d& theP) const;
122
123   //! Computes the distance between two lines.
124   Standard_Real Distance (const gp_Lin2d& theOther) const;
125
126   //! Computes the square distance between <me> and the point
127   //! <theP>.
128   Standard_Real SquareDistance (const gp_Pnt2d& theP) const;
129
130   //! Computes the square distance between two lines.
131   Standard_Real SquareDistance (const gp_Lin2d& theOther) const;
132
133   //! Computes the line normal to the direction of <me>,
134   //! passing through the point <theP>.
135   gp_Lin2d Normal (const gp_Pnt2d& theP) const
136   {
137     return gp_Lin2d (gp_Ax2d (theP, gp_Dir2d (-(pos.Direction().Y()), pos.Direction().X())));
138   }
139
140   Standard_EXPORT void Mirror (const gp_Pnt2d& theP);
141
142   //! Performs the symmetrical transformation of a line
143   //! with respect to the point <theP> which is the center
144   //! of the symmetry
145   Standard_NODISCARD Standard_EXPORT gp_Lin2d Mirrored (const gp_Pnt2d& theP) const;
146
147   Standard_EXPORT void Mirror (const gp_Ax2d& theA);
148
149   //! Performs the symmetrical transformation of a line
150   //! with respect to an axis placement which is the axis
151   //! of the symmetry.
152   Standard_NODISCARD Standard_EXPORT gp_Lin2d Mirrored (const gp_Ax2d& theA) const;
153
154   void Rotate (const gp_Pnt2d& theP, const Standard_Real theAng) { pos.Rotate(theP, theAng); }
155
156   //! Rotates a line. theP is the center of the rotation.
157   //! theAng is the angular value of the rotation in radians.
158   Standard_NODISCARD gp_Lin2d Rotated (const gp_Pnt2d& theP, const Standard_Real theAng) const
159   {
160     gp_Lin2d aL = *this;
161     aL.pos.Rotate (theP, theAng);
162     return aL;
163   }
164
165   void Scale (const gp_Pnt2d& theP, const Standard_Real theS) { pos.Scale (theP, theS); }
166
167   //! Scales a line. theS is the scaling value. Only the
168   //! origin of the line is modified.
169   Standard_NODISCARD gp_Lin2d Scaled (const gp_Pnt2d& theP, const Standard_Real theS) const
170   {
171     gp_Lin2d aL = *this;
172     aL.pos.Scale (theP, theS);
173     return aL;
174   }
175
176   void Transform (const gp_Trsf2d& theT) { pos.Transform (theT); }
177
178   //! Transforms a line with the transformation theT from class Trsf2d.
179   Standard_NODISCARD gp_Lin2d Transformed (const gp_Trsf2d& theT) const
180   {
181     gp_Lin2d aL = *this;
182     aL.pos.Transform (theT);
183     return aL;
184   }
185
186   void Translate (const gp_Vec2d& theV) { pos.Translate (theV); }
187
188   //! Translates a line in the direction of the vector theV.
189   //! The magnitude of the translation is the vector's magnitude.
190   Standard_NODISCARD gp_Lin2d Translated (const gp_Vec2d& theV) const
191   {
192     gp_Lin2d aL = *this;
193     aL.pos.Translate (theV);
194     return aL;
195   }
196
197   void Translate (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) { pos.Translate (theP1, theP2); }
198
199   //! Translates a line from the point theP1 to the point theP2.
200   Standard_NODISCARD gp_Lin2d Translated (const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) const
201   {
202     gp_Lin2d aL = *this;
203     aL.pos.Translate (gp_Vec2d (theP1, theP2));
204     return aL;
205   }
206
207 private:
208
209   gp_Ax2d pos;
210
211 };
212
213 //=======================================================================
214 //function : Distance
215 // purpose :
216 //=======================================================================
217 inline Standard_Real gp_Lin2d::Distance (const gp_Pnt2d& theP) const
218 {
219   gp_XY aCoord = theP.XY();
220   aCoord.Subtract ((pos.Location()).XY());
221   Standard_Real aVal = aCoord.Crossed (pos.Direction().XY());
222   if (aVal < 0)
223   {
224     aVal = -aVal;
225   }
226   return aVal;
227 }
228
229 //=======================================================================
230 //function : Distance
231 // purpose :
232 //=======================================================================
233 inline Standard_Real gp_Lin2d::Distance (const gp_Lin2d& theOther) const
234 {
235   Standard_Real aD = 0.0;
236   if (pos.IsParallel (theOther.pos, gp::Resolution()))
237   {
238     aD = theOther.Distance (pos.Location());
239   }
240   return aD;
241 }
242
243 //=======================================================================
244 //function : SquareDistance
245 // purpose :
246 //=======================================================================
247 inline Standard_Real gp_Lin2d::SquareDistance (const gp_Pnt2d& theP) const
248 {
249   gp_XY aCoord = theP.XY();
250   aCoord.Subtract ((pos.Location()).XY());
251   Standard_Real aD = aCoord.Crossed (pos.Direction().XY());
252   return aD * aD;
253 }
254
255 //=======================================================================
256 //function : SquareDistance
257 // purpose :
258 //=======================================================================
259 inline Standard_Real gp_Lin2d::SquareDistance (const gp_Lin2d& theOther) const
260 {
261   Standard_Real aD = 0.0;
262   if (pos.IsParallel (theOther.pos, gp::Resolution()))
263   {
264     aD = theOther.SquareDistance (pos.Location());
265   }
266   return aD;
267 }
268
269 #endif // _gp_Lin2d_HeaderFile