Quaternion.h

Go to the documentation of this file.

/*
 * Quaternion.h
 *
 *  Created on: 11/12/2012
 *      Author: catec
 */

#ifndef QUATERNION_H_
#define QUATERNION_H_

#include <math.h>
#include <iostream>
#include "TransformationTypes.h"
#include "MathHelper.h"


namespace rotateOp {

class Quaternion {
private:

        double w;
        double x;
        double y;
        double z;

public:

        Quaternion() {
                w = 1;
                x = 0;
                y = 0;
                z = 0;

        }

        Quaternion(double w, double x, double y, double z) {
                this->w = w;
                this->x = x;
                this->y = y;
                this->z = z;

        }


        void fromEuler(double roll, double pitch, double yaw,
                        TransformationTypes::EulerType type) {
                // Assuming the angles are in radians.
                double c1 = (double) (cos(roll * 0.5f));
                double s1 = (double) (sin(roll * 0.5f));
                double c2 = (double) (cos(pitch * 0.5f));
                double s2 = (double) (sin(pitch * 0.5f));
                double c3 = (double) (cos(yaw * 0.5f));
                double s3 = (double) (sin(yaw * 0.5f));
                switch (type) {
                case TransformationTypes::EULER123:

                        w = MathHelper::roundDecimal(c1 * c2 * c3 - s1 * s2 * s3, 5);
                        x = MathHelper::roundDecimal(s1 * c2 * c3 + c1 * s2 * s3, 5);
                        y = MathHelper::roundDecimal(c1 * s2 * c3 - s1 * c2 * s3, 5);
                        z = MathHelper::roundDecimal(c1 * c2 * s3 + s1 * s2 * c3, 5);
                        break;
                case TransformationTypes::EULER321:

                        w = MathHelper::roundDecimal(c3 * c2 * c1 + s3 * s2 * s1, 5);
                        x = MathHelper::roundDecimal(c3 * c2 * s1 - s3 * s2 * c1, 5);
                        y = MathHelper::roundDecimal(c3 * s2 * c1 + s3 * c2 * s1, 5);
                        z = MathHelper::roundDecimal(s3 * c2 * c1 - c3 * s2 * s1, 5);
                        break;

                case TransformationTypes::EULER312:

                        w = MathHelper::roundDecimal(c3 * c1 * c2 - s3 * s1 * s2, 5);
                        x = MathHelper::roundDecimal(s1 * c3 * c2 - s3 * c1 * s2, 5);
                        y = MathHelper::roundDecimal(s3 * s1 * c2 + c3 * c1 * s2, 5);
                        z = MathHelper::roundDecimal(s3 * c1 * c2 + c3 * s1 * s2, 5);
                        break;

                default:
                        std::cerr << "This euler type is not implemented." << std::endl;
                //      assert(true);
                        break;
                }

        }

        double *toArray() {
                double *quaternionArray = new double[4];
                quaternionArray[0] = MathHelper::roundDecimal(w, 5);
                quaternionArray[1] = MathHelper::roundDecimal(x, 5);
                quaternionArray[2] = MathHelper::roundDecimal(y, 5);
                quaternionArray[3] = MathHelper::roundDecimal(z, 5);
                return quaternionArray;
        }

        friend std::ostream & operator <<(std::ostream & o, Quaternion q) {
                o << "Quaternion: [" << q.w << ", (" << q.x << ", " << q.y << ", "
                                << q.z << ")]";
                return o;
        }

        double getW() const {
                return w;
        }

        double getX() const {
                return x;
        }

        double getY() const {
                return y;
        }

        double getZ() const {
                return z;
        }

};
}
#endif /* QUATERNION_H_ */