R3.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP. 
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



/* @{ */

#ifndef __R3_H_
#define __R3_H_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <stdio.h>
#include <math.h>
#include <vector>
#include <iostream>
#include <string>
#include <sstream>
#include <sys/time.h>
#include <sys/select.h>
#include <assert.h>

//BOOST SERIALIZATION
#ifdef FOUND_BOOST_SER
 #include <boost/serialization/vector.hpp>
 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
#endif


#include <Types.h>
#include <Association.h>
#include <S1.h>
#include <R2.h>

#define R3_COORD(VECT)  VECT.x(),VECT.y(),VECT.z()
#define R3_VAR_COORD(VECT,X,Y,Z)  VECT.X,VECT.Y,VECT.Z

using namespace std;

class Position3D {
 
 private:
#ifdef FOUND_BOOST_SER
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
   ar & _x;
   ar & _y;
   ar & _z;
  }
#endif
 
 protected:
  Decimal _x;
  Decimal _y;
  Decimal _z;

 public:
  Position3D();
  
  Position3D(const Decimal &x_in, const Decimal& y_in, const Decimal& z_in);
  
  Position3D(const vector<Decimal>& v);
  
  Position3D(Decimal v[3]);
  
  Position3D(const Angle& phi, const Angle& theta);
  
  Position3D(const Decimal& ro, const Angle& phi, const Decimal& zita);
  
  Position3D(const Decimal& ro, const Angle& phi, const Angle& theta);
  
  Position3D(const Position& pos, const Decimal& z);
  
  Position3D(const Position3D& p);
  
  Position3D& operator=(const Position3D& rhs);
  
  Position3D operator -() const;
  
  Position3D& operator+=(const Position3D& a) ;
  
  Position3D& operator-=(const Position3D& a);
  
  Position3D& operator*=(const Decimal& scalar);
  
  Position3D& operator/=(const Decimal& scalar);
  
  Position3D operator+(const Position3D &other) const;
  
  Position3D operator-(const Position3D &other) const;
  
  Position3D operator*(const Decimal& scalar) const;
  
  Position3D operator/(const Decimal& scalar) const;
  
  Position3D& operator*=(const Position3D &pos);
  
  Position3D& operator/=(const Position3D &pos);
  
  /*const */Position3D operator*(const Position3D &pos) const;
  
  /*const */Position3D operator/(const Position3D &pos) const;
  
  bool operator==(const Position3D &other) const;
  
  bool operator!=(const Position3D &other) const;
  
  bool operator<(const Position3D &other) const;
  
  bool operator>(const Position3D &other) const;
  
  bool operator<=(const Position3D &other) const;
  
  bool operator>=(const Position3D &other) const;
  
  vector<Decimal> vect() const;
  
  void vect(vector<Decimal>&) const;
  
  void vect(Decimal v[3]) const;
  
  Position3D maximum(const Position3D& p) const;
  
  Position3D minimum(const Position3D& p) const;
  
  Position3D unit() const;
  
  Decimal x() const;
  
  Decimal y() const;
  
  Decimal z() const;
    
  void setX(const Decimal& val);
      
  void setY(const Decimal& val);
    
  void setZ(const Decimal& val);

  Decimal norm() const;
  
  Decimal squareNorm() const;
  
  Decimal dist(Position3D &p) const;
  
  Angle azimuth() const;
  
  Angle zenith() const;
  
  Decimal scalar(const Position3D &p) const;
  
  Position3D linearMap(Decimal m[3][3]) const;
  
  Position3D satNorm(const Decimal& sat);
  
  virtual string print(PrintTypes type = PRINT_TYPE_WITH_UNITS) const;

  // String getter & setter (Syntax "x,y,z")
  bool fromString(const string& s);
  string toString() const;
};


// class Acceleration3D;

class Velocity3D : public Position3D{
 private:
#ifdef FOUND_BOOST_SER
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
   ar & _x;
   ar & _y;
   ar & _z;
  }
#endif
 public:

  Velocity3D() : Position3D() {}
  
  Velocity3D(Decimal x_in,Decimal y_in,Decimal z_in) : Position3D(x_in,y_in,z_in) {}
  
  Velocity3D(const Velocity3D& p) {
   _x=p._x; 
   _y=p._y; 
   _z=p._z;
  }
  
  Velocity3D(vector<Decimal> v) : Position3D(v){}
  
  Velocity3D(Decimal v[3]) : Position3D(v){};
  
  // (mriedel:) This does nothing
  //using Position3D::operator=;
  
  //using Position3D::operator+;
  
  //using Position3D::operator-;
  
  //using Position3D::operator/;
  
  //using Position3D::operator*;
  
  Velocity3D(Position3D p) : Position3D(p) {
  }
  
  virtual string print(PrintTypes type = PRINT_TYPE_WITH_UNITS) const;
}; 

class Acceleration3D : public Position3D{
 private:
#ifdef FOUND_BOOST_SER
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int version){
   ar & _x;
   ar & _y;
   ar & _z;
  }
#endif

 public:
  Acceleration3D() : Position3D() {}
  
  Acceleration3D(Decimal x_in,Decimal y_in,Decimal z_in) : Position3D(x_in,y_in,z_in) {}
  
  Acceleration3D(const Acceleration3D& p) {
   _x=p._x; 
   _y=p._y; 
   _z=p._z;
  }
  
  Acceleration3D(vector<Decimal> v) : Position3D(v){}
  
  Acceleration3D(Decimal v[3]) : Position3D(v){};
  
  // mriedel: This does nothing
  //using Position3D::operator=;
  
  //using Position3D::operator+;
  
  //using Position3D::operator-;
  
  //using Position3D::operator/;
  
  //using Position3D::operator*;
  
  Acceleration3D(Position3D p) : Position3D(p) {
  }
  
  virtual string print(PrintTypes type = PRINT_TYPE_WITH_UNITS) const;
}; 


#endif



/* @} */