Surface.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 __SURFACE_H_
#define __SURFACE_H_

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

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

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

#include <R3.h>
#include <S1.h>
#include <S3.h>
//#include <MIPMatrix.h>

#define MAX_NUM_PLANES 5000
#define PLANES_DATA_ELEMENTS 7
#define TRANS_MATRIX_DATA 9 
#define SOURCE_FILE_COLUMNS 22
#define SOURCE_FILE_X_COORD_POS 0
#define SOURCE_FILE_Z_COORD_POS 2
#define SOURCE_FILE_a_COEFF_POS 18
#define SOURCE_FILE_d_COEFF_POS 21
#define X_COORD_POS 0
#define Y_COORD_POS 1
#define Z_COORD_POS 2
#define a_COEFF_POS 3
#define b_COEFF_POS 4
#define c_COEFF_POS 5
#define d_COEFF_POS 6

using namespace std;

class Surface {
 private:
//#ifdef FOUND_BOOST_SER
//  friend class boost::serialization::access;
//  //std::cout.precision(15);
//#endif
  
  int NumPlanes;  // Number of plane composing the road.
  char* nome;
  
  Decimal DataIn[MAX_NUM_PLANES][PLANES_DATA_ELEMENTS];// Array containig the relevant information about a point and a
                           // plane containing it. For each row we have:
                           // X,Y,Z coordinates of a point; a,b,c,d coefficients of plane equation
                           // containing the point.
  
  MIPMatrix *RotTransl;
  
  int CalcNumPlanes(const char* file)//Read file to get the number of the planes composing the surface.
  {
   int tmp = 0;
   ifstream leggerefile(file,ios::in);
   char tempBuffer[200];
   leggerefile.getline (tempBuffer, 199);
   while(!(leggerefile.eof()))
   {
    leggerefile.getline (tempBuffer, 199);
    tmp++;
   }
   return tmp;
  }
    
  // Function to fill the DataIn table with the data read from an external file. 
  void BuildMatrixOfReferenceData(string namefile)
  {
     int q = 0;
     int row = 0;
     int col = 0;
     double tmp=0;
     const char *ptr1 = 0;
     char *ptr2 = 0;
     string filedata;
     
     fstream filestr;
     cout << "BuildMatrixOfReferenceData() " << "\n";
     filestr.open(namefile.c_str(), ios::in);
     while(!(filestr.eof()) && (row < NumPlanes) && (row < MAX_NUM_PLANES))
     {
         filestr >> filedata;
        if(!(filestr.eof()))
        {
    if((q%SOURCE_FILE_COLUMNS) == 0)
       cout << "\n" << "Riga tabella:  " << row+1 << "\n";
//    cout << "From file: " << q << "\n";
//                       cout << "Val " << q << "= " << filedata << "\n";
                         ptr1 = filedata.data();
                         tmp = atof(ptr1);
                         // tmp = strtod(ptr1, &ptr2);                
                         if((((q % SOURCE_FILE_COLUMNS) >= SOURCE_FILE_X_COORD_POS ) && ((q % SOURCE_FILE_COLUMNS) <= SOURCE_FILE_Z_COORD_POS)) || 
       (((q % SOURCE_FILE_COLUMNS) >= SOURCE_FILE_a_COEFF_POS) && ((q % SOURCE_FILE_COLUMNS) <= SOURCE_FILE_d_COEFF_POS)))
                         {
                            DataIn[row][col] = tmp;                  
                            cout << "DataIn[" << row << "," << col << "]= " << DataIn[row][col] << "; ";
                            col = (col+1)%7;
                         }
                         q++; 
                         if((q % SOURCE_FILE_COLUMNS) == 0)
    {
                            row++;
       //cout << "\n";
    }
                       }
                   }
                   //leggerefile.close();
     filestr.close();
     cout << "\n";
     return;
  }

                // Build transformation matrices array
  void BuildRotTranslMatrix();
  
 public:
  Surface(string namefile)
  {
   cout << "Surface construction started." << "\n";
   RotTransl = new MIPMatrix[MAX_NUM_PLANES]();
   NumPlanes = CalcNumPlanes(namefile.c_str());//Number of planes defined in input data file 1 plane for each file's row.
//    NumPlanes = NumPlanes - 1;//last plane can't be used because there is no reference point after.
   cout << "Surface description file: " << namefile.c_str() << "\n";
   cout << "NumPlanes = " << NumPlanes << "\n";
   BuildMatrixOfReferenceData(namefile);
   BuildRotTranslMatrix();
   cout << "Surface model construction OK." << endl;
  }
  
  
  ~Surface ()
  {
     delete[] RotTransl;
     cout << "destr Surface" << endl;
  }
  
      // Get num planes in surface.
  int ReadNumPlanes()
  { 
     return NumPlanes;
  }
  
  // Get Transformation matrix element.
  Decimal GetRotTranslMatrixElem(int NumMatrix, int row, int col)
  {  
     int i;
     
     i = (row - 1)*3 + (col - 1);
     return RotTransl[NumMatrix].GetMIPMatrixVal(row,col);
  }

  // Get Transformation matrix.
  MIPMatrix* GetRotTranslMatrix(int NumMatrix)
  {  
     return &RotTransl[NumMatrix];
  }


      // Get DataIn matrix element.
  Position3D GetPlaneRefPoint(int Plane)
  {  
     return Position3D(DataIn[Plane][0], DataIn[Plane][1], DataIn[Plane][2]);
  }
  
      // Get "a" coefficient of plane equation.
  Decimal GetCoef_a(int Plane)
  {  
     return DataIn[Plane][3];
  }
  
      // Get "b" coefficient of plane equation.
  Decimal GetCoef_b(int Plane)
  {  
     return DataIn[Plane][4];
  }

      // Get "c" coefficient of plane equation.
  Decimal GetCoef_c(int Plane)
  {  
     return DataIn[Plane][5];
  }

      // Get "d" coefficient of plane equation.
  Decimal GetCoef_d(int Plane)
  {  
     return DataIn[Plane][6];
  }
};
#endif


/* @} */