Jpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
JEulerAngle3D.hh
Go to the documentation of this file.
1 #ifndef __JEULERANGLE3D__
2 #define __JEULERANGLE3D__
3 
4 #include <istream>
5 #include <ostream>
6 
7 #include "JIO/JSerialisable.hh"
8 #include "JMath/JMath.hh"
9 #include "JMath/JConstants.hh"
10 
11 #include "JGeometry3D/JAngle3D.hh"
12 #include "JGeometry3D/JVersor3D.hh"
13 
14 
15 /**
16  * \author mdejong
17  */
18 
19 namespace JGEOMETRY3D {}
20 namespace JPP { using namespace JGEOMETRY3D; }
21 
22 namespace JGEOMETRY3D {
23 
24  using JMATH::PI;
25  using JMATH::JMath;
26  using JIO::JReader;
27  using JIO::JWriter;
28 
29 
30  /**
31  * Data structure for Euler angles in three dimensions.
32  *
33  * This class implements the JMATH::JMath interface.
34  */
35  class JEulerAngle3D :
36  public JMath<JEulerAngle3D>
37  {
38  public:
39  /**
40  * Default constructor.
41  */
43  __alpha(0.0),
44  __beta (0.0),
45  __gamma(0.0)
46  {}
47 
48 
49  /**
50  * Constructor.
51  *
52  * \param alpha alpha angle [rad]
53  * \param beta beta angle [rad]
54  * \param gamma gamma angle [rad]
55  */
56  JEulerAngle3D(const double alpha,
57  const double beta,
58  const double gamma) :
59  __alpha(alpha),
60  __beta (beta),
61  __gamma(gamma)
62  {}
63 
64 
65  /**
66  * Constructor.
67  *
68  * \param angle angle
69  */
70  JEulerAngle3D(const JAngle3D& angle) :
71  __alpha(PI/2),
72  __beta (angle.getTheta()),
73  __gamma(angle.getPhi() + PI/2)
74  {}
75 
76 
77  /**
78  * Constructor.
79  *
80  * \param versor versor
81  */
82  JEulerAngle3D(const JVersor3D& versor) :
83  __alpha(PI/2),
84  __beta (versor.getTheta()),
85  __gamma(versor.getPhi() + PI/2)
86  {}
87 
88 
89  /**
90  * Get Euler angle.
91  *
92  * \return this angle
93  */
95  {
96  return static_cast<const JEulerAngle3D&>(*this);
97  }
98 
99 
100  /**
101  * Set Euler angle.
102  *
103  * \param angle Euler angle
104  */
105  void setEulerAngle(const JEulerAngle3D& angle)
106  {
107  static_cast<JEulerAngle3D&>(*this) = angle;
108  }
109 
110 
111  /**
112  * Negate angle.
113  *
114  * \return this angle
115  */
117  {
118  __alpha = -__alpha;
119  __beta = -__beta;
120  __gamma = -__gamma;
121 
122  return *this;
123  }
124 
125 
126  /**
127  * Add angle.
128  *
129  * \param angle angle
130  * \return this angle
131  */
133  {
134  __alpha += angle.getAlpha();
135  __beta += angle.getBeta();
136  __gamma += angle.getGamma();
137 
138  return *this;
139  }
140 
141 
142  /**
143  * Subtract angle.
144  *
145  * \param angle angle
146  * \return this angle
147  */
149  {
150  __alpha -= angle.getAlpha();
151  __beta -= angle.getBeta();
152  __gamma -= angle.getGamma();
153 
154  return *this;
155  }
156 
157 
158  /**
159  * Scale angle.
160  *
161  * \param factor multiplication factor
162  * \return this angle
163  */
164  JEulerAngle3D& mul(const double factor)
165  {
166  __alpha *= factor;
167  __beta *= factor;
168  __gamma *= factor;
169 
170  return *this;
171  }
172 
173 
174  /**
175  * Scale angle.
176  *
177  * \param factor division factor
178  * \return this angle
179  */
180  JEulerAngle3D& div(const double factor)
181  {
182  __alpha /= factor;
183  __beta /= factor;
184  __gamma /= factor;
185 
186  return *this;
187  }
188 
189 
190  /**
191  * Get alpha angle.
192  *
193  * \return alpha angle
194  */
195  double getAlpha() const
196  {
197  return __alpha;
198  }
199 
200 
201  /**
202  * Get beta angle.
203  *
204  * \return beta angle
205  */
206  double getBeta() const
207  {
208  return __beta;
209  }
210 
211 
212  /**
213  * Get gamma angle.
214  *
215  * \return gamma angle
216  */
217  double getGamma() const
218  {
219  return __gamma;
220  }
221 
222 
223  /**
224  * Read Euler angles from input.
225  *
226  * \param in input stream
227  * \param angle Euler angles
228  * \return input stream
229  */
230  friend inline std::istream& operator>>(std::istream& in, JEulerAngle3D& angle)
231  {
232  in >> angle.__alpha >> angle.__beta >> angle.__gamma;
233 
234  return in;
235  }
236 
237 
238  /**
239  * Write Euler angles to output.
240  *
241  * \param out output stream
242  * \param angle Euler angle
243  * \return output stream
244  */
245  friend inline std::ostream& operator<<(std::ostream& out, const JEulerAngle3D& angle)
246  {
247  out << angle.getAlpha() << ' ' << angle.getBeta() << ' ' << angle.getGamma();
248 
249  return out;
250  }
251 
252 
253  /**
254  * Read Euler angles from input.
255  *
256  * \param in reader
257  * \param angle Euler angles
258  * \return reader
259  */
260  friend inline JReader& operator>>(JReader& in, JEulerAngle3D& angle)
261  {
262  in >> angle.__alpha;
263  in >> angle.__beta;
264  in >> angle.__gamma;
265 
266  return in;
267  }
268 
269 
270  /**
271  * Write Euler angles to output.
272  *
273  * \param out writer
274  * \param angle Euler angles
275  * \return writer
276  */
277  friend inline JWriter& operator<<(JWriter& out, const JEulerAngle3D& angle)
278  {
279  out << angle.__alpha;
280  out << angle.__beta;
281  out << angle.__gamma;
282 
283  return out;
284  }
285 
286 
287  protected:
288  double __alpha;
289  double __beta;
290  double __gamma;
291  };
292 }
293 
294 #endif
JEulerAngle3D(const JVersor3D &versor)
Constructor.
Data structure for angles in three dimensions.
Definition: JAngle3D.hh:33
Data structure for Euler angles in three dimensions.
double getGamma() const
Get gamma angle.
Interface for binary output.
JEulerAngle3D & negate()
Negate angle.
Auxiliary base class for aritmetic operations of derived class types.
Definition: JMath.hh:110
void setEulerAngle(const JEulerAngle3D &angle)
Set Euler angle.
JEulerAngle3D & add(const JEulerAngle3D &angle)
Add angle.
JEulerAngle3D(const JAngle3D &angle)
Constructor.
double getAlpha() const
Get alpha angle.
double getBeta() const
Get beta angle.
const JEulerAngle3D & getEulerAngle() const
Get Euler angle.
Mathematical constants.
JEulerAngle3D()
Default constructor.
friend JWriter & operator<<(JWriter &out, const JEulerAngle3D &angle)
Write Euler angles to output.
JEulerAngle3D & div(const double factor)
Scale angle.
static const double PI
Mathematical constants.
friend JReader & operator>>(JReader &in, JEulerAngle3D &angle)
Read Euler angles from input.
Interface for binary input.
friend std::istream & operator>>(std::istream &in, JEulerAngle3D &angle)
Read Euler angles from input.
JEulerAngle3D & mul(const double factor)
Scale angle.
JEulerAngle3D & sub(const JEulerAngle3D &angle)
Subtract angle.
friend std::ostream & operator<<(std::ostream &out, const JEulerAngle3D &angle)
Write Euler angles to output.
Base class for data structures with artithmetic capabilities.
JEulerAngle3D(const double alpha, const double beta, const double gamma)
Constructor.
Data structure for normalised vector in three dimensions.
Definition: JVersor3D.hh:26
then fatal Wrong number of arguments fi set_variable DETECTOR $argv[1] set_variable INPUT_FILE $argv[2] eval JPrintDetector a $DETECTOR O IDENTIFIER eval JPrintDetector a $DETECTOR O SUMMARY source JAcoustics sh $DETECTOR_ID typeset A TRIPODS get_tripods $WORKDIR tripod txt TRIPODS for EMITTER in
Definition: JCanberra.sh:36