SoloffCamera.hpp

Go to the documentation of this file.

/*
 * Copyright(c):
 * Signal Image and Communications (SIC) Department 
 * http://www.sic.sp2mi.univ-poitiers.fr/ 
 *  - University of Poitiers, France http://www.univ-poitiers.fr 
 *  - XLIM  Institute UMR CNRS 7252  http://www.xlim.fr/ 
 * 
 * and 
 * 
 * D2 Fluid, Thermic and Combustion 
 *  - University of Poitiers, France http://www.univ-poitiers.fr 
 *  - PPRIME Institute -  UPR CNRS 3346  http://www.pprime.fr
 *  - ISAE-ENSMA http://www.ensma.fr
 *
 * Contributor(s):
 * The SLIP team,
 * Benoit Tremblais <tremblais_AT_sic.univ-poitiers.fr>,
 * Laurent David <laurent.david_AT_lea.univ-poitiers.fr>, 
 * Ludovic Chatellier <ludovic.chatellier_AT_univ-poitiers.fr>, 
 * Lionel Thomas <lionel.thomas_AT_univ-poitiers.fr>, 
 * Denis Arrivault <arrivault_AT_sic.univ-poitiers.fr>, 
 * Julien Dombre <julien.dombre_AT_univ-poitiers.fr>.
 *
 * Description:
 * The Simple Library of Image Processing (SLIP) is a new image processing 
 * library. It is written in the C++ language following as much as possible 
 * the ISO/ANSI C++ standard. It is consequently compatible with any system  
 * satisfying the ANSI C++ complience. It works on different Unix , Linux ,  
 * Mircrosoft Windows and Mac OS X plateforms. SLIP is a research library that  
 * was created by the Signal, Image and Communications (SIC) departement of  
 * the XLIM, UMR 7252 CNRS Institute in collaboration with the Fluids, Thermic  
 * and Combustion departement of the P', UPR 3346 CNRS Institute of the  
 * University of Poitiers.
 * 
 * The SLIP Library source code has been registered to the APP (French Agency 
 * for the Protection of Programs) by the University of Poitiers and CNRS, 
 * under  registration number IDDN.FR.001.300034.000.S.P.2010.000.21000.

 * http://www.sic.sp2mi.univ-poitiers.fr/slip/
 *
 * This software is governed by the CeCILL-C license under French law and
 * abiding by the rules of distribution of free software.  You can  use, 
 * modify and/ or redistribute the software under the terms of the CeCILL-C 
 * license as circulated by CEA, CNRS and INRIA at the following URL 
 * http://www.cecill.info.
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 * 
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the 
 * same conditions as regards security. 
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-C license and that you accept its terms.
 */



#ifndef SLIP_SOLOFFCAMERA_HPP
#define SLIP_SOLOFFCAMERA_HPP

#include <iostream>
#include <cassert>
#include "Point2d.hpp"
#include "Point3d.hpp"
#include "Vector3d.hpp"
#include "Matrix.hpp"
#include "io_tools.hpp"
#include "CameraModel.hpp"
#include "camera_algo.hpp"
#include "polynomial_algo.hpp"

#include <boost/serialization/access.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/base_object.hpp>

namespace slip 
{
  template <typename Type>
  class SoloffCamera;

  template <typename Type>
  std::ostream& operator<<(std::ostream & out, const slip::SoloffCamera<Type>& c);

  template <typename Type>
  class SoloffCamera:public slip::CameraModel<Type> {
    typedef slip::SoloffCamera<Type> self;
    typedef slip::CameraModel<Type> base;
  public:

    SoloffCamera():
      calibration_polynomial_x_(new slip::MultivariatePolynomial<Type,3>((std::size_t)3)),
      calibration_polynomial_y_(new slip::MultivariatePolynomial<Type,3>((std::size_t)3)),
      calibration_polynomial_X_(new slip::MultivariatePolynomial<Type,3>((std::size_t)3)),
      calibration_polynomial_Y_(new slip::MultivariatePolynomial<Type,3>((std::size_t)3)),
      calibration_polynomial_coeff_x_(new slip::Array<Type>(20)),
      calibration_polynomial_coeff_y_(new slip::Array<Type>(20)),
      calibration_polynomial_coeff_X_(new slip::Array<Type>(20)),
      calibration_polynomial_coeff_Y_(new slip::Array<Type>(20))
    {
    }
    SoloffCamera(const self& rhs):
      base(rhs),
      calibration_polynomial_x_(new slip::MultivariatePolynomial<Type,3>(*(rhs.calibration_polynomial_x_))),
      calibration_polynomial_y_(new slip::MultivariatePolynomial<Type,3>(*(rhs.calibration_polynomial_y_))),
      calibration_polynomial_X_(new slip::MultivariatePolynomial<Type,3>(*(rhs.calibration_polynomial_X_))),
      calibration_polynomial_Y_(new slip::MultivariatePolynomial<Type,3>(*(rhs.calibration_polynomial_Y_))),
      calibration_polynomial_coeff_x_(new slip::Array<Type>(*(rhs.calibration_polynomial_coeff_x_))),
      calibration_polynomial_coeff_y_(new slip::Array<Type>(*(rhs.calibration_polynomial_coeff_y_))),
      calibration_polynomial_coeff_X_(new slip::Array<Type>(*(rhs.calibration_polynomial_coeff_X_))),
      calibration_polynomial_coeff_Y_(new slip::Array<Type>(*(rhs.calibration_polynomial_coeff_Y_)))

    {}

    ~SoloffCamera()
    {
      delete calibration_polynomial_x_;
      delete calibration_polynomial_y_;
      delete calibration_polynomial_X_;
      delete calibration_polynomial_Y_;
      delete calibration_polynomial_coeff_x_;
      delete calibration_polynomial_coeff_y_;
      delete calibration_polynomial_coeff_X_;
      delete calibration_polynomial_coeff_Y_;
    }

    friend std::ostream& operator<< <>(std::ostream & out, const self& c);

    self& operator=(const self & rhs)
    {
       if(this != &rhs)
       {
                this->base::operator=(rhs);

                if(calibration_polynomial_x_ != 0)
                  {
                    delete calibration_polynomial_x_;
                  }
                calibration_polynomial_x_ = new slip::MultivariatePolynomial<Type,3>(*(rhs.calibration_polynomial_x_));
                if(calibration_polynomial_y_ != 0)
                  {
                    delete calibration_polynomial_y_;
                  }
                calibration_polynomial_y_ = new slip::MultivariatePolynomial<Type,3>(*(rhs.calibration_polynomial_y_));                                                                                                                              
                if(calibration_polynomial_X_ != 0)
                  {
                    delete calibration_polynomial_X_;
                  }
                 calibration_polynomial_X_ = new slip::MultivariatePolynomial<Type,3>(*(rhs.calibration_polynomial_X_));                                                                                                             
                if(calibration_polynomial_Y_ != 0)
                  {
                    delete calibration_polynomial_Y_;
                  }
                calibration_polynomial_Y_ = new slip::MultivariatePolynomial<Type,3>(*(rhs.calibration_polynomial_Y_));
                if(calibration_polynomial_coeff_x_ != 0)
                  {
                    delete calibration_polynomial_coeff_x_;
                  }
                calibration_polynomial_coeff_x_ = new slip::Array<Type>(*(rhs.calibration_polynomial_coeff_x_));                                                                                                                     
                if(calibration_polynomial_coeff_y_ != 0)
                  {
                    delete calibration_polynomial_coeff_y_;
                  }
                calibration_polynomial_coeff_y_ = new slip::Array<Type>(*(rhs.calibration_polynomial_coeff_y_));                                                                                                                                 
                if(calibration_polynomial_coeff_X_ != 0)
                  {
                    delete calibration_polynomial_coeff_X_;
                  }
                calibration_polynomial_coeff_X_ = new slip::Array<Type>(*(rhs.calibration_polynomial_coeff_X_));
                if(calibration_polynomial_coeff_Y_ != 0)
                  {
                    delete calibration_polynomial_coeff_Y_;
                  }
                calibration_polynomial_coeff_Y_ = new slip::Array<Type>(*(rhs.calibration_polynomial_coeff_Y_));

       }
    return *this;
  }
    slip::MultivariatePolynomial<Type,3>& calibration_polynomial_x() const
    {
      return *calibration_polynomial_x_;
    }

    void calibration_polynomial_x(const slip::MultivariatePolynomial<Type,3>& calibration_polynomial_x)
    {
      assert(calibration_polynomial_x.degree() == 3);
      *(this->calibration_polynomial_x_) = calibration_polynomial_x;
      calibration_polynomial_x.all_coeff(this->calibration_polynomial_coeff_x_->begin(),
                                                                                 this->calibration_polynomial_coeff_x_->end());                                                  
    }
    
    slip::MultivariatePolynomial<Type,3>& calibration_polynomial_y() const
    {
      return *calibration_polynomial_y_;
    }
 
   void calibration_polynomial_y(const slip::MultivariatePolynomial<Type,3>& calibration_polynomial_y)
    {
      assert(calibration_polynomial_y.degree() == 3);
      *(this->calibration_polynomial_y_) = calibration_polynomial_y;
      calibration_polynomial_y.all_coeff(this->calibration_polynomial_coeff_y_->begin(),
                                                                                 this->calibration_polynomial_coeff_y_->end());                                                  
    }
    
  
     slip::MultivariatePolynomial<Type,3>& calibration_polynomial_X() const
    {
      return *calibration_polynomial_X_;
    }
   
     void calibration_polynomial_X(const slip::MultivariatePolynomial<Type,3>& calibration_polynomial_X)
    {
       assert(calibration_polynomial_X.degree() == 3);
      *(this->calibration_polynomial_X_) = calibration_polynomial_X;
      calibration_polynomial_X.all_coeff(this->calibration_polynomial_coeff_X_->begin(),
                                                                                 this->calibration_polynomial_coeff_X_->end());                                                  
    }
  
    slip::MultivariatePolynomial<Type,3>& calibration_polynomial_Y()
    {
      return *calibration_polynomial_Y_;
    }
 
      void calibration_polynomial_Y(const slip::MultivariatePolynomial<Type,3>& calibration_polynomial_Y)
    {
       assert(calibration_polynomial_Y.degree() == 3);
      *(this->calibration_polynomial_Y_) = calibration_polynomial_Y;
      calibration_polynomial_Y.all_coeff(this->calibration_polynomial_coeff_Y_->begin(),
                                                                                 this->calibration_polynomial_coeff_Y_->end());                                                  
    }
  
    slip::Array<Type>& calibration_polynomial_coeff_x() const
    {
      return *calibration_polynomial_coeff_x_;
    }
    template <typename RandomAccessIterator>
    void calibration_polynomial_coeff_x(RandomAccessIterator first,
                                                                                RandomAccessIterator last) 
    {
      assert((last-first) == 20);
      *calibration_polynomial_coeff_x_ = slip::Array<Type>(static_cast<std::size_t>(last-first),first,last);
      *calibration_polynomial_x_ = slip::MultivariatePolynomial<Type,3>(3,first,last);
      
    }
    slip::Array<Type>& calibration_polynomial_coeff_y() const
    {
      return *calibration_polynomial_coeff_y_;
    }

    template <typename RandomAccessIterator>
    void calibration_polynomial_coeff_y(RandomAccessIterator first,
                                                                                RandomAccessIterator last) 
    {
      assert((last-first) == 20);
      *calibration_polynomial_coeff_y_ = slip::Array<Type>(static_cast<std::size_t>(last-first),first,last);
      *calibration_polynomial_y_ = slip::MultivariatePolynomial<Type,3>(3,first,last);
      
    }
    slip::Array<Type>& calibration_polynomial_coeff_X() const
    {
      return *calibration_polynomial_coeff_X_;
    }

      template <typename RandomAccessIterator>
    void calibration_polynomial_coeff_X(RandomAccessIterator first,
                                                                                RandomAccessIterator last) 
    {
      assert((last-first) == 20);
      *calibration_polynomial_coeff_X_ = slip::Array<Type>(static_cast<std::size_t>(last-first),first,last);
      *calibration_polynomial_X_ = slip::MultivariatePolynomial<Type,3>(3,first,last);
      
    }

    slip::Array<Type>& calibration_polynomial_coeff_Y() const
    {
      return *calibration_polynomial_coeff_Y_;
    }

    template <typename RandomAccessIterator>
    void calibration_polynomial_coeff_Y(RandomAccessIterator first,
                                                                                RandomAccessIterator last) 
    {
      assert((last-first) == 20);
      *calibration_polynomial_coeff_Y_ = slip::Array<Type>(static_cast<std::size_t>(last-first),first,last);
      *calibration_polynomial_Y_ = slip::MultivariatePolynomial<Type,3>(3,first,last);
      
    }
    inline
    slip::Point2d<Type> projection(const slip::Point3d<Type>& p) 
    {
           
      Type px =  
           (*calibration_polynomial_coeff_x_)[0] 
                + p[0]*(   (*calibration_polynomial_coeff_x_)[1]
                                + p[0]*((*calibration_polynomial_coeff_x_)[2] + (*calibration_polynomial_coeff_x_)[3]*p[0])
                                + p[1]*((*calibration_polynomial_coeff_x_)[5] +
                                     (*calibration_polynomial_coeff_x_)[6] *p[0] +
                                     (*calibration_polynomial_coeff_x_)[8] *p[1] +
                                     (*calibration_polynomial_coeff_x_)[14]*p[2])
                                + p[2]*((*calibration_polynomial_coeff_x_)[11] +
                                     (*calibration_polynomial_coeff_x_)[12]*p[0] +
                                     (*calibration_polynomial_coeff_x_)[17]*p[2]))
                + p[1] * ((*calibration_polynomial_coeff_x_)[4] + 
                      p[1]*((*calibration_polynomial_coeff_x_)[7]+
                                 (*calibration_polynomial_coeff_x_)[9]*p[1])) 
                + p[2] * ((*calibration_polynomial_coeff_x_)[10] +
                       p[1]*((*calibration_polynomial_coeff_x_)[13]   +
                                  (*calibration_polynomial_coeff_x_)[15]*p[1] +
                                  (*calibration_polynomial_coeff_x_)[18]*p[2]) +
                       p[2]*((*calibration_polynomial_coeff_x_)[16] +
                                  (*calibration_polynomial_coeff_x_)[19]*p[2]));
 Type py =  
           (*calibration_polynomial_coeff_y_)[0] 
                + p[0]*(   (*calibration_polynomial_coeff_y_)[1]
                                + p[0]*((*calibration_polynomial_coeff_y_)[2] + (*calibration_polynomial_coeff_y_)[3]*p[0])
                                + p[1]*((*calibration_polynomial_coeff_y_)[5] +
                                     (*calibration_polynomial_coeff_y_)[6] *p[0] +
                                     (*calibration_polynomial_coeff_y_)[8] *p[1] +
                                     (*calibration_polynomial_coeff_y_)[14]*p[2])
                                + p[2]*((*calibration_polynomial_coeff_y_)[11] +
                                     (*calibration_polynomial_coeff_y_)[12]*p[0] +
                                     (*calibration_polynomial_coeff_y_)[17]*p[2]))
                + p[1] * ((*calibration_polynomial_coeff_y_)[4] + 
                      p[1]*((*calibration_polynomial_coeff_y_)[7]+
                                 (*calibration_polynomial_coeff_y_)[9]*p[1])) 
                + p[2] * ((*calibration_polynomial_coeff_y_)[10] +
                       p[1]*((*calibration_polynomial_coeff_y_)[13]   +
                                  (*calibration_polynomial_coeff_y_)[15]*p[1] +
                                  (*calibration_polynomial_coeff_y_)[18]*p[2]) +
                       p[2]*((*calibration_polynomial_coeff_y_)[16] +
                                  (*calibration_polynomial_coeff_y_)[19]*p[2]));
   
      return slip::Point2d<Type>(px,py);
    }

    inline
    slip::Point3d<Type> backprojection(const slip::Point2d<Type>& p2, 
                                                                       const Type& z) 
    {
       Type pX =  
           (*calibration_polynomial_coeff_X_)[0] 
                + p2[0]*(   (*calibration_polynomial_coeff_X_)[1]
                                + p2[0]*((*calibration_polynomial_coeff_X_)[2] + (*calibration_polynomial_coeff_X_)[3]*p2[0])
                                + p2[1]*((*calibration_polynomial_coeff_X_)[5] +
                                     (*calibration_polynomial_coeff_X_)[6] *p2[0] +
                                     (*calibration_polynomial_coeff_X_)[8] *p2[1] +
                                     (*calibration_polynomial_coeff_X_)[14]*z)
                                + z*((*calibration_polynomial_coeff_X_)[11] +
                                     (*calibration_polynomial_coeff_X_)[12]*p2[0] +
                                     (*calibration_polynomial_coeff_X_)[17]*z))
                + p2[1] * ((*calibration_polynomial_coeff_X_)[4] + 
                      p2[1]*((*calibration_polynomial_coeff_X_)[7]+
                                 (*calibration_polynomial_coeff_X_)[9]*p2[1])) 
                + z * ((*calibration_polynomial_coeff_X_)[10] +
                       p2[1]*((*calibration_polynomial_coeff_X_)[13]   +
                                  (*calibration_polynomial_coeff_X_)[15]*p2[1] +
                                  (*calibration_polynomial_coeff_X_)[18]*z) +
                       z*((*calibration_polynomial_coeff_X_)[16] +
                                  (*calibration_polynomial_coeff_X_)[19]*z));
 Type pY =  
           (*calibration_polynomial_coeff_Y_)[0] 
                + p2[0]*(   (*calibration_polynomial_coeff_Y_)[1]
                                + p2[0]*((*calibration_polynomial_coeff_Y_)[2] + (*calibration_polynomial_coeff_Y_)[3]*p2[0])
                                + p2[1]*((*calibration_polynomial_coeff_Y_)[5] +
                                     (*calibration_polynomial_coeff_Y_)[6] *p2[0] +
                                     (*calibration_polynomial_coeff_Y_)[8] *p2[1] +
                                     (*calibration_polynomial_coeff_Y_)[14]*z)
                                + z*((*calibration_polynomial_coeff_Y_)[11] +
                                     (*calibration_polynomial_coeff_Y_)[12]*p2[0] +
                                     (*calibration_polynomial_coeff_Y_)[17]*z))
                + p2[1] * ((*calibration_polynomial_coeff_Y_)[4] + 
                      p2[1]*((*calibration_polynomial_coeff_Y_)[7]+
                                 (*calibration_polynomial_coeff_Y_)[9]*p2[1])) 
                + z * ((*calibration_polynomial_coeff_Y_)[10] +
                       p2[1]*((*calibration_polynomial_coeff_Y_)[13]   +
                                  (*calibration_polynomial_coeff_Y_)[15]*p2[1] +
                                  (*calibration_polynomial_coeff_Y_)[18]*z) +
                       z*((*calibration_polynomial_coeff_Y_)[16] +
                                  (*calibration_polynomial_coeff_Y_)[19]*z));
   
       return slip::Point3d<Type>(pX,pY,z);
    }

    void compute(const slip::Matrix<Type>& P) 
    {
      getpars_SoloffUV(P,*calibration_polynomial_x_,*calibration_polynomial_y_);
      getpars_SoloffXY(P,*calibration_polynomial_X_,*calibration_polynomial_Y_);
      calibration_polynomial_x_->all_coeff(calibration_polynomial_coeff_x_->begin(),
                                                                                   calibration_polynomial_coeff_x_->end());
      calibration_polynomial_y_->all_coeff(calibration_polynomial_coeff_y_->begin(),
                                                                                 calibration_polynomial_coeff_y_->end());
      calibration_polynomial_X_->all_coeff(calibration_polynomial_coeff_X_->begin(),
                                                                                   calibration_polynomial_coeff_X_->end());
      calibration_polynomial_Y_->all_coeff(calibration_polynomial_coeff_Y_->begin(),
                                                                                   calibration_polynomial_coeff_Y_->end());
    }

    void read(const std::string& file) {
      slip::Array2d<double> F;
      slip::read_ascii_2d(F,file);
      slip::Vector<Type> mu(20), mv(20),mX(20), mY(20);
      for(int i=0; i<20; i++) {
                mu[i]=F[i][0]; mv[i]=F[i][1]; mX[i]=F[i][2]; mY[i]=F[i][3];
      }
      slip::MultivariatePolynomial<Type,3> Pu(3,mu.begin(),mu.end());
      slip::MultivariatePolynomial<Type,3> Pv(3,mv.begin(),mv.end());
      slip::MultivariatePolynomial<Type,3> PX(3,mX.begin(),mX.end());
      slip::MultivariatePolynomial<Type,3> PY(3,mY.begin(),mY.end());
      *calibration_polynomial_x_=Pu;
      *calibration_polynomial_y_=Pv;
      *calibration_polynomial_X_=PX;
      *calibration_polynomial_Y_=PY;
      std::copy(mu.begin(),mu.end(),calibration_polynomial_coeff_x_->begin());
      std::copy(mv.begin(),mv.end(),calibration_polynomial_coeff_y_->begin());
      std::copy(mX.begin(),mX.end(),calibration_polynomial_coeff_X_->begin());
      std::copy(mY.begin(),mY.end(),calibration_polynomial_coeff_Y_->begin());
    }
    void write(const std::string& file) {

      std::ofstream output(file.c_str(),std::ios::out);
      slip::Vector<Type> mu(20), mv(20),mX(20), mY(20);
      calibration_polynomial_x_->all_coeff(mu.begin(),mu.end());
      calibration_polynomial_y_->all_coeff(mv.begin(),mv.end());
      calibration_polynomial_X_->all_coeff(mX.begin(),mX.end());
      calibration_polynomial_Y_->all_coeff(mY.begin(),mY.end());
      for(int i=0;i<20; i++){
                output<<mu[i]<<" "<<mv[i]<<" "<<mX[i]<<" "<<mY[i]<<std::endl;
      }
      output.close();

    }
    //protected:
    slip::MultivariatePolynomial<Type,3> *calibration_polynomial_x_;
    slip::MultivariatePolynomial<Type,3> *calibration_polynomial_y_;
    slip::MultivariatePolynomial<Type,3> *calibration_polynomial_X_;
    slip::MultivariatePolynomial<Type,3> *calibration_polynomial_Y_;
    slip::Array<Type>* calibration_polynomial_coeff_x_;
    slip::Array<Type>* calibration_polynomial_coeff_y_;
    slip::Array<Type>* calibration_polynomial_coeff_X_;
    slip::Array<Type>* calibration_polynomial_coeff_Y_;
    
  private:
        friend class boost::serialization::access;
    template<class Archive>
    void save(Archive & ar, const unsigned int version) const
    {
      ar & boost::serialization::base_object<slip::CameraModel<Type> >(*this);
      ar & calibration_polynomial_x_;
      ar & calibration_polynomial_y_;
      ar & calibration_polynomial_X_;
      ar & calibration_polynomial_Y_;
      ar & calibration_polynomial_coeff_x_;
      ar & calibration_polynomial_coeff_y_;
      ar & calibration_polynomial_coeff_X_;
      ar & calibration_polynomial_coeff_Y_;
      
    }
  template<class Archive>
    void load(Archive & ar, const unsigned int version)
    {
      ar & boost::serialization::base_object<slip::CameraModel<Type> >(*this);
      ar & calibration_polynomial_x_;
      ar & calibration_polynomial_y_;
      ar & calibration_polynomial_X_;
      ar & calibration_polynomial_Y_;
      ar & calibration_polynomial_coeff_x_;
      ar & calibration_polynomial_coeff_y_;
      ar & calibration_polynomial_coeff_X_;
      ar & calibration_polynomial_coeff_Y_;
    }
   BOOST_SERIALIZATION_SPLIT_MEMBER()
  };

}//slip::


namespace slip {

  template<typename Type>
  std::ostream& operator<<(std::ostream & out, const slip::SoloffCamera<Type>& c) {
    slip::MultivariatePolynomial<Type,3> MPx=*c.calibration_polynomial_x_;
    slip::MultivariatePolynomial<Type,3> MPy=*c.calibration_polynomial_y_;
    slip::MultivariatePolynomial<Type,3> MPX=*c.calibration_polynomial_X_;
    slip::MultivariatePolynomial<Type,3> MPY=*c.calibration_polynomial_Y_;

    out<<MPx<<std::endl;
    out<<MPy<<std::endl;
    out<<MPX<<std::endl;
    out<<MPY<<std::endl;
    return out;
  }

}//slip::
#endif //SLIP_SOLOFFCAMERA_HPP