alvelocity3d.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012 Aldebaran Robotics. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the COPYING file.
 */


#pragma once
#ifndef _LIBALMATH_ALMATH_TYPES_ALVELOCITY3D_H_
#define _LIBALMATH_ALMATH_TYPES_ALVELOCITY3D_H_

#include <vector>

namespace AL {
  namespace Math {

    struct Velocity3D {
      float xd;
      float yd;
      float zd;


      Velocity3D();


      explicit Velocity3D(float pInit);


      Velocity3D(
        float pXd,
        float pYd,
        float pZd);


      Velocity3D(const std::vector<float>& pFloats);

      inline Velocity3D operator+ (const Velocity3D& pVel2) const
      {
        return Velocity3D(xd + pVel2.xd, yd + pVel2.yd, zd + pVel2.zd);
      }

      inline Velocity3D operator- (const Velocity3D& pVel2) const
      {
        return Velocity3D(
              xd - pVel2.xd,
              yd - pVel2.yd,
              zd - pVel2.zd);
      }

      inline Velocity3D operator+ (void) const
      {
        return *this;
      }

      inline Velocity3D operator- () const
      {
        return Velocity3D(-xd, -yd, -zd);
      }

      Velocity3D& operator+= (const Velocity3D& pVel2);

      Velocity3D& operator-= (const Velocity3D& pVel2);

      bool operator== (const Velocity3D& pVel2) const;

      bool operator!= (const Velocity3D& pVel2) const;

      inline Velocity3D operator* (const float pVal) const
      {
        return Velocity3D(xd*pVal, yd*pVal, zd*pVal);
      }

      Velocity3D operator/ (const float pVal) const;

      Velocity3D& operator*= (const float pVal);

      Velocity3D& operator/= (const float pVal);

      bool isNear(
        const Velocity3D& pVel2,
        const float&      pEpsilon=0.0001f) const;


      float norm () const;

      Velocity3D normalize() const;

      void toVector(std::vector<float>& pReturnValue) const;
      std::vector<float> toVector(void) const;

      void writeToVector(std::vector<float>::iterator& pIt) const;
    };

    Velocity3D operator* (
      const float       pM,
      const Velocity3D& pVel1);

    float norm (const Velocity3D& pVel);

    Velocity3D normalize(const Velocity3D& pVel);

  } // end namespace Math
} // end namespace AL
#endif  // _LIBALMATH_ALMATH_TYPES_ALVELOCITY3D_H_