math_euler.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_MATH_EULER_H_
#define DESIGNLAB_MATH_EULER_H_
 
#include <string>
 
#include "math_util.h"
#include "math_vector3.h"
 
namespace designlab {
 
struct EulerXYZ final {
  constexpr EulerXYZ() : x_angle(0.f), y_angle(0.f), z_angle(0.f) {}
 
  constexpr EulerXYZ(const float x, const float y, const float z)
      : x_angle(x), y_angle(y), z_angle(z) {}
 
  constexpr EulerXYZ(const EulerXYZ& other) = default;
  constexpr EulerXYZ(EulerXYZ&& other) noexcept = default;
  constexpr EulerXYZ& operator=(const EulerXYZ& other) = default;
 
  ~EulerXYZ() = default;
 
  constexpr EulerXYZ operator*(const float s) const noexcept {
    return {x_angle * s, y_angle * s, z_angle * s};
  }
 
  constexpr bool operator==(const EulerXYZ& other) const noexcept {
    using math_util::IsEqual;
 
    return IsEqual(x_angle, other.x_angle) && IsEqual(y_angle, other.y_angle) &&
           IsEqual(z_angle, other.z_angle);
  }
 
  constexpr bool operator!=(const EulerXYZ& other) const noexcept {
    return !(*this == other);
  }
 
  constexpr void SetDeg(const float x, const float y, const float z) {
    x_angle = math_util::ConvertDegToRad(x);
    y_angle = math_util::ConvertDegToRad(y);
    z_angle = math_util::ConvertDegToRad(z);
  }
 
  [[nodiscard]] std::string ToString() const;
 
  [[nodiscard]] std::string ToCsvString() const;
 
  [[nodiscard]] std::string ToStringDeg() const;
 
  [[nodiscard]] static constexpr EulerXYZ MakeEulerXYZDeg(const float x,
                                                          const float y,
                                                          const float z) {
    using math_util::ConvertDegToRad;
    return EulerXYZ{ConvertDegToRad(x), ConvertDegToRad(y), ConvertDegToRad(z)};
  }
 
  float x_angle;  
  float y_angle;  
  float z_angle;  
};
 
template <class Char>
inline std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& os,
                                            const EulerXYZ& r) {
  using math_util::FloatingPointNumToString;
 
  os << FloatingPointNumToString(r.x_angle) << Char(',')
     << FloatingPointNumToString(r.y_angle) << Char(',')
     << FloatingPointNumToString(r.z_angle);
 
  return os;
}
 
template <class Char>
inline std::basic_istream<Char>& operator>>(std::basic_istream<Char>& is,
                                            EulerXYZ& r) {
  Char unused = 0;
  return is >> unused >> r.x_angle >> unused >> r.y_angle >> unused >>
         r.z_angle >> unused;
}
 
[[nodiscard]] Vector3 RotateVector3(const Vector3& vec, const EulerXYZ& rot);
 
}  // namespace designlab
 
#endif  // DESIGNLAB_MATH_EULER_H_