source: flair-src/trunk/lib/FlairCore/src/Euler.cpp@ 204

// %flair:license{
// This file is part of the Flair framework distributed under the
// CECILL-C License, Version 1.0.
// %flair:license}
//  created:    2013/05/02
//  filename:   Euler.cpp
//
//  author:     Guillaume Sanahuja
//              Copyright Heudiasyc UMR UTC/CNRS 7253
//
//  version:    $Id: $
//
//  purpose:    Class defining euler angles
//
//
/*********************************************************************/

#include "Euler.h"
#include "Quaternion.h"
#include <math.h>

#define PI ((float)3.14159265358979323846)
#define PI_D ((double)3.14159265358979323846)

namespace flair {
namespace core {

Euler::Euler(float inRoll, float inPitch, float inYaw)
    : roll(inRoll), pitch(inPitch), yaw(inYaw) {}

Euler::~Euler() {}

Euler &Euler::operator=(const Euler &euler) {
  roll = euler.roll;
  pitch = euler.pitch;
  yaw = euler.yaw;
  return (*this);
}
/*
void Euler::RotateX(float value) {
    float pitch_tmp;
    pitch_tmp=pitch*cosf(value)+yaw*sinf(value);
    yaw=-pitch*sinf(value)+yaw*cosf(value);
    pitch=pitch_tmp;
    roll+=value;
    if(roll<-PI) roll+=2*PI;
    if(roll>PI) roll-=2*PI;
}

void Euler::RotateXDeg(float value) {
    RotateX(ToRadian(value));
}

void Euler::RotateY(float value) {
    float roll_tmp;
    roll_tmp=roll*cosf(value)-yaw*sinf(value);
    yaw=roll*sinf(value)+yaw*cosf(value);
    roll=roll_tmp;
    pitch+=value;
    if(pitch<-PI) pitch+=2*PI;
    if(pitch>PI) pitch-=2*PI;
}

void Euler::RotateYDeg(float value) {
    RotateY(ToRadian(value));
}

void Euler::RotateZ(float value) {
    float roll_tmp;
    roll_tmp=roll*cosf(value)+pitch*sinf(value);
    pitch=-roll*sinf(value)+pitch*cosf(value);
    roll=roll_tmp;
    yaw+=value;
    if(yaw<-PI) yaw+=2*PI;
    if(yaw>PI) yaw-=2*PI;
}

void Euler::RotateZDeg(float value) {
    RotateZ(ToRadian(value));
}
*/
void Euler::ToQuaternion(Quaternion &quaternion) const {
  quaternion.q0 = cos(yaw / 2) * cos(pitch / 2) * cos(roll / 2) +
                  sin(yaw / 2) * sin(pitch / 2) * sin(roll / 2);

  quaternion.q1 = cos(yaw / 2) * cos(pitch / 2) * sin(roll / 2) -
                  sin(yaw / 2) * sin(pitch / 2) * cos(roll / 2);

  quaternion.q2 = cos(yaw / 2) * sin(pitch / 2) * cos(roll / 2) +
                  sin(yaw / 2) * cos(pitch / 2) * sin(roll / 2);

  quaternion.q3 = sin(yaw / 2) * cos(pitch / 2) * cos(roll / 2) -
                  cos(yaw / 2) * sin(pitch / 2) * sin(roll / 2);
}

Quaternion Euler::ToQuaternion(void) const {
  Quaternion quaternion;
  ToQuaternion(quaternion);
  return quaternion;
}

float Euler::ToDegree(float radianValue) { return radianValue * 180.0f / PI; }

float Euler::ToRadian(float degreeValue) { return degreeValue / 180.0f * PI; }

float Euler::YawDistanceFrom(float angle) const {
  float rot1, rot2;
  if (angle > yaw) {
    rot1 = angle - yaw;
    rot2 = 2 * PI - angle + yaw;
  } else {
    rot1 = 2 * PI + angle - yaw;
    rot2 = yaw - angle;
  }
  
  if (rot2 < rot1) rot1 = -rot2;
  
  rot1 = -rot1; // pour avoir rot1=yaw-angle

  return rot1;
}

} // end namespace core
} // end namespace flair