R2.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 __R2_H_
#define __R2_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>

using namespace std;

class Position {
 
 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;
    }
#endif
 
 protected:
  Decimal _x;
  Decimal _y;

 public:
  Position();
  
  Position(const Decimal& x_in,const Decimal& y_in);
  
  Position(const Angle& theta);
  
  Position(const Decimal &d,const Angle& theta);
  
  Position(const Position& p);
  
  void setX (const Decimal& x);
  
  void setY (const Decimal& y);
  
  Position& operator=(const Position& rhs);
  
  Position& operator+=(const Position& a);
  
  Position& operator-=(const Position& a);
  
  Position& operator*=(const Decimal& scalar);
  
  Position& operator/=(const Decimal& scalar);
  
  Position& operator+=(const Decimal& scalar);
  
  Position& operator+=(const Angle& angle);
  
  Position& operator-=(const Decimal& scalar);
  
  Position& operator-=(const Angle& angle);
  
  Position operator+(const Decimal &other) const;
  
  Position operator-(const Decimal &other) const;
  
  Position operator+(const Angle &other) const;
  
  Position operator-(const Angle &other) const;
  
  Position operator+(const Position &other) const;
  
  Position operator-(const Position &other) const;
  
  Position operator*(const Decimal& scalar) const;
  
  Position operator/(const Decimal& scalar) const;
  
  bool operator==(const Position &other) const;
  
  bool operator!=(const Position &other) const;
  
  Position minimum(const Position& p) const;
  
  Position maximum(const Position& p) const;
  
  Decimal x() const;
  
  Decimal y() const;
  
  Decimal norm() const;
  
  Decimal squareNorm() const;
  
  Decimal dist(const Position& p) const;
  
  Angle bearing() const;

  Decimal bearingInv() const;
  
  Decimal scalar(const Position& p) const;
  
  vector<Decimal> vectorize() const;
  
  string print(int precision=4) const;
  
  // String getter & setter (Syntax "x,y")
  bool fromString(const string& s);
  string toString() const;
};


class PosiFeature : public Association<Position,int> {
 private:
  
 public:
  int numInliersForThisFeature;
  
  PosiFeature() : Association<Position,int>(){
   numInliersForThisFeature = 1;
  }
  
  PosiFeature (const Position& p) : Association<Position,int>(p){
   numInliersForThisFeature = 1;
  }
  
  PosiFeature (const Position& p, const int i) : Association<Position,int>(p,i){
   numInliersForThisFeature = 1;
  }
  
  PosiFeature (const PosiFeature& f) : Association<Position,int>(f){
   numInliersForThisFeature = f.numInliersForThisFeature;
  };
  
  PosiFeature (stringstream &ss) : Association<Position,int>(){
   PosiFeature tpf(ss);
   numInliersForThisFeature = 1;
   (*this) = tpf;
  };
  
  // TODO: (Martin:) This does nothing!
  
  
  
  PosiFeature& operator=(const PosiFeature& a){
   if (this != &a){      // Not necessary in this case but it is useful to don't forget it
    this->Association<Position,int>::operator=(a);
//     _obj   = a._obj;
//     _assoObj = a._assoObj;
//     _isAsso  = a._isAsso;
    numInliersForThisFeature = a.numInliersForThisFeature;
   }
   return *this;
  }
/* using Association<Position,int>::operator=;*/

  Position getPosition(void) const {
   return getObj();
  }
  int getId(void) const {
   return getAsso();
  }
  void setId(int a) {
   associate(a);
  }
  
  string print() const;

  bool notEqual(const PosiFeature &A, const Decimal& toll) const;

  PosiFeature& mul(const Decimal& scalar);
  
  string exportAsString(){
   stringstream ss;
   ss << this->getId() << " " << this->getPosition().x() << " " << this->getPosition().y();
   return ss.str();
  }
};


// class PosiFeatures : public vector<PosiFeature> {};
typedef vector<PosiFeature> PosiFeatures;


class Observation : public PosiFeatures {
 public:
  
  int nullFeature;
  
  int id;
  
  Observation();
  
  Observation(int ID);
  
  Observation(const PosiFeatures& p, int ID);
  
  Observation (const Observation& f);
  
  Observation (stringstream& ss);
  
  Observation& operator=(const Observation& f);
    
  string print() const;
  
  int insertion(const PosiFeature& p);
  
  bool find(const PosiFeature& p, int& position);
  
  bool find(const int id, int& position);
  
  void init();
  
  string exportAsString();
  
 private:
#ifdef FOUND_BOOST_SER
  friend class boost::serialization::access;
  template<class Archive>
    void serialize(Archive & ar, const unsigned int version){
   
   ar & nullFeature; 
   ar & id;
   ar & &((*this)[0]);
//    ar & size();
//    for(int i = 0; i<size(); i++){
//     ar & (*this)[i];
//    }
    }
#endif

};




#endif



/* @} */