/*
Matrix.h
*/
 
#ifndef __TMATRIX H__
#define __TMATRIX H__
 
#include <iostream>
#include <math.h>
using namespace std;
 
class TMatrixException /* Exception class for TFloatMatix */
{
public:
enum Exception
{
DIM_TOO_SMALL ,
NOT_SAME_DIM ,
NOT_SQUARE ,
NOT_MULTIPLICABLE,
NOT_UNI_COLUMN
};
 
TMatrixException(Exception);
Exception Err;
};
 
template <class T> class TMatrix
{
public:
/* ---------------------- Attributes --------------------------- */
T *M; /* Linear matrix data storage */
T **P; /* Pointers on each rows */
int dimR; /* Number of rows ( column size ) */
int dimC; /* Number of columns ( row size ) */
 
/* ----------------------- Builders --------------------------- */
TMatrix(int ); /* for square matrix */
TMatrix(int dimRow=10, int dimCol=1); /* Default, For NxM matrix */
TMatrix(const TMatrix<T>& ); /* Copy */
~TMatrix(); /* de-allocate memory */
 
/* -------------------- Utils procedures ----------------------- */
void clear(); /* Reset to 0 all elements */
void destroy(); /* de-allocate memory */
TMatrix<T> resize(int,int); /* Set a new dimension */
void resize(int dim=2); /* The same, for square */
void in(T*); /* Input data in a matrix */
ostream& out(ostream& ) const; /* Display matrix on std::out */
 
/* ------------- Functions and procedure on this object ------- */
TMatrix ones();
TMatrix<T> zeros();
TMatrix cofactor(); /* Return cofactor matrix */
T cofactor(int, int); /* 1 element cofactor */
T determinant(); /* Determinant of a matrix */
void transpose(); /* Transpose a matrix*/
TMatrix<T> transpose1(); /* Transpose a matrix that returns a Mtarix*/
void reverse(); /* Reverse a matrix */
void TC(); /* Transpose and cofactor matrix */
TMatrix<T> mean(); /* mean value of array*/
T norm(); /*matrix norms*/
TMatrix<T> fill( const TMatrix<T>& ,const int ) ;
/* ---------------------- Operators ---------------------------- */
TMatrix<T>& operator=(const TMatrix<T>& );
 
TMatrix<T> operator-() ;
TMatrix<T> operator+(const TMatrix<T>& ) ;
TMatrix<T> operator-(const TMatrix<T>& ) ;
TMatrix<T> operator*(const TMatrix<T>& ) ;
TMatrix<T> operator*(const T);
TMatrix<T> operator*=(const T);
TMatrix<T> operator*=(const TMatrix<T>& );
TMatrix<T> operator/(const T );
TMatrix<T> colonne(const int );
T det3x3(); /* return the determinant of a 3x3 matrix */
T det2x2(); /* return the determinant of a 2x2 matrix */
TMatrix<T> mul(const TMatrix<T>& ); /* Multiply two matrices */
};
 
template <class T>
ostream& operator<< (ostream& o, const TMatrix<T>& m)
{return m.out(o);}
 
template <class T>
istream& operator>> (istream&, TMatrix<T>& );
#endif
//===========================================================================
 

// DernierMatrice11-7-06.cpp : définit le point d'entrée pour l'application console.
//
 
#include "stdafx.h"
#include <algorithm>
#include <fstream>
#include <string>
#include <sstream>
#include <functional>
#include "Matrix.h"
using namespace std;
 
TMatrixException::TMatrixException(Exception e) : Err(e)
{
if (e==DIM_TOO_SMALL)
{
cout <<"ERR: DIM TOO SMALL"<<endl<<endl;
system("pause" );
return;//exit(0);
}
if (e==NOT_SAME_DIM)
{
cout <<"FR: Additionner ou soustraire uniquement des ";
cout <<"matrices de meme taille"<<endl;
system("pause" );
return;//exit(0);
}
if (e==NOT_SQUARE)
{
cout <<"FR: Tentative d'utilisation d'une fonction reservee aux ";
cout <<"matrices carrees sur une matrice non-carree."<<endl;
system("pause" );
return;//exit(0);
}
if (e==NOT_MULTIPLICABLE)
{
cout <<"FR: Pour multiplier, le nombre de colonnes de la ";
cout <<"premiere matrice doit etre egal au nombre de lignes ";
cout <<"de la deuxieme."<<endl;
system("pause" );
return;//exit(0);
}
if (e== NOT_UNI_COLUMN )
{
cout <<"FR: Pour faire cette operation, il faut que la matrice a ";
cout <<"une seulle colonne ";
system("pause" );
return;//exit(0);
}
else
{
cout <<"UNKNOW EXCEPTION"<<endl;
system("pause" );
return ;//exit(0);
}
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T>::TMatrix(int dimRow=10, int dimCol=1)
{
if (dimRow<1 || dimCol<1)
throw TMatrixException(TMatrixException::DIM_TOO_SMALL);
 
dimR=dimRow;
dimC=dimCol;
 
M=new T[dimR*dimC*sizeof(T)];
P=new T*[dimR*sizeof(T*)];
 
T *ref;
ref=M;
for (int i=0; i<dimR; i++)
{
P=ref;
ref+=dimC;
}
clear();
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T>::TMatrix(int dim)
{
if (dim<1)
throw TMatrixException(TMatrixException::DIM_TOO_SMALL);
 
dimR=dim;
dimC=dim;
 
 
M=new T[dimR*dimC*sizeof(T)];
P=new T*[dimR*sizeof(T*)];
 
T *ref;
ref=M;
for (int i=0; i<dimR; i++)
{
P=ref;
ref+=dimC;
}
clear();
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T>::TMatrix(const TMatrix<T>& m)
{
dimR=m.dimR;
dimC=m.dimC;
M=m.M;
P=m.P;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T>::~TMatrix()
{
/*delete[] M;
delete[] P;*/
}
//---------------------------------------------------------------------------
 
template <class T>
void TMatrix<T>::destroy()
{
delete[] M;
delete[] P;
}
//---------------------------------------------------------------------------
 
template <class T>
void TMatrix<T>::clear()
{
for (int i=0; i<dimR; i++)
for (int j=0; j<dimC; j++)
P[j]=0;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::resize(int rw, int cl)
{
TMatrix<T> m(rw,cl);
if (dimR*dimC <= rw*cl)
{
for (int i=0; i<dimR;i++)
for (int j=0; j<dimC; j++)
m.P[j]=P[j];
for (int i2=dimR; i2<rw; i2++)
for (int j2=dimC; j2<cl; j2++)
m.P[i2][j2]=0;
}
else
{
for (int i=0; i<rw;i++)
for (int j=0; j<cl; j++)
m.P[j]=P[j];
}
*this=m;
return *this;
}
//---------------------------------------------------------------------------
 
template <class T>
void TMatrix<T>::resize(int dim)
{
TMatrix<T> m(dim);
if (dimR*dimC <= dim*dim)
{
for (int i=0; i<dimR;i++)
for (int j=0; j<dimC; j++)
m.P[j]=P[j];
for (int i2=dimR; i2<dim; i2++)
for (int j2=dimC; j2<dim; j2++)
m.P[i2][j2]=0;
}
else
{
for (int i=0; i<dim;i++)
for (int j=0; j<dim; j++)
m.P[j]=P[j];
}
*this=m;
}
//---------------------------------------------------------------------------
 
template <class T>
void TMatrix<T>::in(T *data)
{
for (int i=0; i<dimR;i++)
for (int j=0; j<dimC; j++)
P[j]=data[dimC*i+j];
}
//---------------------------------------------------------------------------
 
template <class T>
ostream& TMatrix<T>::out(ostream& o) const
{
for (int i=0; i<dimR; i++)
{
for (int j=0; j<dimC; j++)
o <<P[j]<<" ";
o <<endl;
}
return o;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::ones()
{
for (int i=0; i<dimR;i++)
for (int j=0; j<dimC; j++)
P[j]=1;
return *this;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::zeros()
{
for (int i=0; i<dimR;i++)
for (int j=0; j<dimC; j++)
P[j]=0;
return *this;
}
 
//---------------------------------------------------------------------------
template <class T>
TMatrix<T> TMatrix<T>::colonne(const int f)
{
TMatrix<T> r(dimR,1);
 
for (int i=0; i<dimR; i++)
{
r.P[0]=P[f];
}
return r;
}
//---------------------------------------------------------------------------
template <class T>
TMatrix<T> TMatrix<T>::fill( const TMatrix<T>& m , int f)
{
if (m.dimC>1)
throw TMatrixException(TMatrixException::NOT_UNI_COLUMN);
 
TMatrix<T> r(dimR,dimC);
for (int i=0; i<dimR; i++)
P[f]=m.P[0];
 
 
 
return *this;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::mean() //TMatrix<T>
{
T *tab= new T [dimC];//=new double [5];
int dimI=1;
for (int j=0; j<dimC; j++)
tab[j]=0;
for (int i=0; i<dimR;i++)
for (int j=0; j<dimC; j++)
tab[j]+= P[j];
 
TMatrix<T> r(dimI,dimC);
for (int i=0; i<dimI; i++)
for (int j=0; j<dimC; j++)
r.P[0][j]= tab[j]/float(dimR);
 
return r;
}
//---------------------------------------------------------------------------
template <class T>
T TMatrix<T>::norm()
{
double Add=0;
 
for (int i=0; i<dimR; i++)
{
for (int j=0; j<dimC; j++)
Add+= pow(P[j],2);
}
double norm= sqrt(Add);
return norm;
 
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T>& TMatrix<T>::operator=(const TMatrix<T>& m)
{
dimR=m.dimR;
dimC=m.dimC;
M=m.M;
P=m.P;
return *this;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::operator-()
{
TMatrix<T> r(dimR,dimC);
r=*this * T(-1);
return r;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::operator+(const TMatrix<T>& m)
{
if (dimR!=m.dimR || dimC!=m.dimC)
throw TMatrixException(TMatrixException::NOT_SAME_DIM);
 
TMatrix<T> r(dimR,dimC);
for (int i=0; i<dimR; i++)
for (int j=0; j<dimC; j++)
r.P[j]=P[j]+m.P[j];
return r;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::operator-(const TMatrix<T>& m)
{
if (dimR!=m.dimR || dimC!=m.dimC)
throw TMatrixException(TMatrixException::NOT_SAME_DIM);
 
TMatrix<T> r(dimR,dimC);
for (int i=0; i<dimR; i++)
for (int j=0; j<dimC; j++)
r.P[j]=P[j]-m.P[j];
return r;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::operator*(const TMatrix<T>& m)
{
if (dimC!=m.dimR)
throw TMatrixException(TMatrixException::NOT_MULTIPLICABLE);
 
TMatrix<T> r(dimR,m.dimC);
r=this->mul(m);
return r;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::operator*(const T f)
{
for (int i=0; i<dimR; i++)
for (int j=0; j<dimC; j++)
P[j]*=f;
return *this;
}
//---------------------------------------------------------------------------
template <class T>
TMatrix<T> TMatrix<T>::operator/(const T f)
{
TMatrix<T> r(dimR,dimC);
for (int i=0; i<dimR; i++)
for (int j=0; j<dimC; j++)
r.P[j]=P[j]/f;
return r;
}
//---------------------------------------------------------------------------
template <class T>
TMatrix<T> TMatrix<T>::operator*=(const TMatrix<T>& m)
{
if (dimR!=m.dimR || dimC!=m.dimC)
throw TMatrixException(TMatrixException::NOT_SAME_DIM);
 
TMatrix<T> r(dimR,dimC);
for (int i=0; i<dimR; i++)
for (int j=0; j<dimC; j++)
r.P[j]=P[j]*m.P[j];
return r;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::operator*=(const T f)
{
*this=*this*f;
return *this;
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::mul(const TMatrix<T>& m)
{
TMatrix<T> r(dimR,m.dimC);
T e=0;
for (int i=0; i<dimR; i++)
for (int j=0; j<m.dimC; j++)
{
for (int k=0; k<dimC; k++)
e+=P[k]*m.P[k][j];
r.P[j]=e;
e=0;
}
return r;
}
//---------------------------------------------------------------------------
 
template <class T>
void TMatrix<T>::reverse()
{
if (dimR!=dimC)
throw TMatrixException(TMatrixException::NOT_SQUARE);
 
TMatrix<T> r(dimR,dimC);
r=cofactor();
r.transpose();
for (int i=0; i<dimR; i++)
for (int j=0; j<dimR; j++)
r.P[j]=r.P[j]*pow(-1,i+j+2);
r*=T(1)/determinant();
*this=r;
}
//---------------------------------------------------------------------------
 
template <class T>
void TMatrix<T>::TC()
{
if (dimR!=dimC)
throw TMatrixException(TMatrixException::NOT_SQUARE);
 
TMatrix<T> r(dimR,dimC);
r=cofactor();
r.transpose();
for (int i=0; i<dimR; i++)
for (int j=0; j<dimR; j++)
r.P[j]=r.P[j]*pow(-1,i+j+2);
*this=r;
}
//---------------------------------------------------------------------------
template <class T>
void TMatrix<T>::transpose()
{
TMatrix<T> m(dimC,dimR);
for (int i=0; i<dimC; i++)
for (int j=0; j<dimR; j++)
{ m.P[j]=P[j];}
*this=m;
}
//---------------------------------------------------------------------------
template <class T>
TMatrix<T> TMatrix<T>::transpose1()
{
TMatrix<T> m(dimC,dimR);
for (int i=0; i<dimC; i++)
for (int j=0; j<dimR; j++)
{ m.P[j]=P[j];}
return m;
}
//---------------------------------------------------------------------------
 
template <class T>
T TMatrix<T>::det3x3()
{
return P[0][0] * ( (P[1][1]*P[2][2])-(P[1][2]*P[2][1]) )
- P[1][0] * ( (P[0][1]*P[2][2])-(P[0][2]*P[2][1]) )
+ P[2][0] * ( (P[0][1]*P[1][2])-(P[0][2]*P[1][1]) );
}
//---------------------------------------------------------------------------
 
template <class T>
T TMatrix<T>::det2x2()
{
return P[0][0]*P[1][1] - P[0][1]*P[1][0];
}
//---------------------------------------------------------------------------
 
template <class T>
T TMatrix<T>::determinant()
{
if (dimR!=dimC)
throw TMatrixException(TMatrixException::NOT_SQUARE);
 
if (dimR==2) return det2x2();
if (dimR==3) return det3x3();
T d=0;
for (int i=0; i<dimR; i++)
d+=P[0] * cofactor(i,0);
return d;
}
//---------------------------------------------------------------------------
 
template <class T>
T TMatrix<T>::cofactor(int ir, int ic)
{
if (dimR!=dimC)
throw TMatrixException(TMatrixException::NOT_SQUARE);
 
return minor(ir,ic) * pow(-1, ir+ic+2);
}
//---------------------------------------------------------------------------
 
template <class T>
TMatrix<T> TMatrix<T>::cofactor()
{
if (dimR!=dimC)
throw TMatrixException(TMatrixException::NOT_SQUARE);
 
TMatrix<T> r(dimR);
for (int i=0; i<dimR; i++)
for (int j=0; j<dimR; j++)
r.P[j]=cofactor(i,j);
return r;
}
//---------------------------------------------------------------------------
 
template <class T>
istream& operator>> (istream& in, TMatrix<T> &m)
{
int rw,cl;
cout << "DIM ROW: ";
in >> rw;
cout << "DIM COL: ";
in >> cl;
 
if (rw<1 && cl<1)
throw TMatrixException(TMatrixException::DIM_TOO_SMALL);
 
m.resize(rw,cl);
T *data=new T[rw*cl];
T element;
for (int i=0; i<rw; i++)
for (int j=0; j<cl; j++)
{
cout << i <<','<<j<<':';
in >> element;
data[cl*i+j]=element;
}
for (int x=0; x<rw; x++)
for (int y=0; y<cl; y++)
m.P[x][y]=data[cl*x+y];
delete [] data;
return in;
}
 
int nbLigne = 0;
int nbline = 0;
 
main()
{
int fonction();
 
int nbligne=10;
int nbcolonne=100000;
 
double **tab = new double* [nbligne];
 
string *tab1=new string [10];
 
double *data0 =new double [100000];
double *data1 =new double [100000];
double *data2 =new double [100000];
double *data3 =new double [100000];
double *data4 =new double [100000];
double *data5 =new double [100000];
double *data6 =new double [100000];
double *data7 =new double [100000];
double *data8 =new double [100000];
double *data9 =new double [100000];
double *data11 =new double [100000];
 
int *nb= new int [10];
 
tab1[0]="image_aller_0.txt";
tab1[1]="image_aller_1.txt";
tab1[2]="image_aller_2.txt";
tab1[3]="image_aller_3.txt";
tab1[4]="image_aller_4.txt";
tab1[5]="image_retour_0.txt";
tab1[6]="image_retour_1.txt";
tab1[7]="image_retour_2.txt";
tab1[8]="image_retour_3.txt";
tab1[9]="image_retour_4.txt";
 
 
for(int i=0;i<nbligne;i++)
{
tab =new double [nbcolonne];
ifstream fichier( tab1.c_str() );
 
int nbElement = 0;
 
if ( fichier ) // ce test échoue si le fichier n'est pas ouvert
{
 
string ligne; // variable contenant chaque ligne lue
while ( getline( fichier, ligne,';') )
{
stringstream s;
s << ligne;
double n;
s >> n;
tab[nbElement]=n;
nbElement++;
}
 
nbElement=nbElement-1;
nb=nbElement;
}
}
 
 
 
 
 
 
fonction();
/*for (int j=0;j<nb[0];j++)
{data11[j]=tab[9][j];
cout<<"data11["<<j<<"]="<<data11[j]<<endl;}*/
//calcul des images d'aller
for(int i=24*(nb[0]/nbLigne), int j=0;i<nb[0];i++,j++)
{
data0[j]=tab[0];
}
 
for(int i=18*(nb[0]/nbLigne), int j=0;i<nb[0]-6*(nb[0]/nbLigne);i++,j++)
{
data1[j]=tab[1];
}
 
for(int i=12*(nb[0]/nbLigne), int j=0;i<nb[0]-12*(nb[0]/nbLigne);i++,j++)
{
data2[j]=tab[2];
}
 
for(int i=6*(nb[0]/nbLigne), int j=0;i<nb[0]-18*(nb[0]/nbLigne);i++,j++)
{
data3[j]=tab[3];
}
 
for(int i=0, int j=0;i<nb[0]-24*(nb[0]/nbLigne);i++,j++)
{
data4[j]=tab[4];
}
 
 
//calcul des images d'aller
for(int i=24*(nb[0]/nbLigne), int j=0;i<nb[0];i++,j++)
{
data5[j]=tab[5];
}
 
for(int i=18*(nb[0]/nbLigne), int j=0;i<nb[0]-6*(nb[0]/nbLigne);i++,j++)
{
data6[j]=tab[6];
}
 
for(int i=12*(nb[0]/nbLigne), int j=0;i<nb[0]-12*(nb[0]/nbLigne);i++,j++)
{
data7[j]=tab[7];
}
 
for(int i=6*(nb[0]/nbLigne), int j=0;i<nb[0]-18*(nb[0]/nbLigne);i++,j++)
{
data8[j]=tab[8];
}
 
for(int i=0, int j=0;i<nb[0]-24*(nb[0]/nbLigne);i++,j++)
{
data9[j]=tab[9];
//cout<<"data4["<<j<<"]="<<data4[j]<<endl;
}
 
for (i=0; i<nbligne; i++)
delete [] tab;
 
 
double BaseDeb0[]={0.388604604904631,0.406601659145942,0.378690501334562,0.287194079690545,0.151164359264193,
0.071803015062962,0.164350538222389,0.296797179332217,0.38334997634639,0.409525836418349};
 
double BaseDeb1[]={-0.323649350549774,-0.415607636283671,-0.411387612488962,-0.333930284418496,-0.222511513692899,
0.198907038265443,0.295558748176889,0.345093175771535,0.311521060527922,0.221826868643937};
 
double BaseDeb2[]={-0.670820408061754,-0.207550671690524,0.060710285463047,0.175467860721236,0.342103337312563,
0.314378516305185,0.373036501457469,0.269042406605554,0.205073746200055,-0.054627425664033};
 
double BaseDeb3[]={-0.12178458628382,-0.324322138954493,-0.294336964125752,0.080655254257347,0.20264198781655,
-0.110319603693933,-0.268477620124972,-0.27861221882445,0.174640119162963,0.743912483995695};
 
double BaseDeb4[]={0.357419420677741,0.116967766567915,-0.322458372355591,-0.252697005439953,0.593422649796283,
0.386988742706195,0.289990311108721,-0.190522196734433,-0.261592915955397,-0.000225632241136};
 
double BaseDeb5[]={0.387835479914384,-0.472426972046061,-0.263024747425621,0.300572963862179,0.281961266092815,
-0.292920124870451,-0.10040664044921,0.412249012263593,0.147553636167751,-0.315852972131101};
 
double BaseDeb6[]={-0.232892894649326,0.274303457352688,0.069140668314326,-0.498922811704185,0.399528412251487,
-0.568973419522421,-0.105702986671391,0.328946616074605,-0.091031579887583,0.076122653515312};
 
double BaseDeb7[]={-0.043700740700225,0.234278105335433,-0.145635777001948,-0.142465914460769,0.142713443772678,
-0.026476339204742,-0.156393666411569,-0.386796655515969,0.755421457350252,-0.368642597766829};
 
double BaseDeb8[]={0.185010748856839,-0.531092263105224,0.654417098449992,-0.426670672208321,0.131653353167031,
0.143286525831791,-0.091305299504505,-0.116947513280103,0.115389066867978,-0.014518277895676};
 
double BaseDeb9[]={0.059496218389855,-0.140590273388129,0.066195283690816,0.057676418204699,-0.061972012911959,
-0.530559523333651,0.73961121061749,-0.366254928633776,0.042273129917483,0.026416262209347};
 
TMatrix <double> A0(nbLigne-24,nb[0]/nbLigne),sig1(nbLigne-24,nb[0]/nbLigne),c(nbLigne-24,1),
A1(nbLigne-24,nb[0]/nbLigne),sig2(nbLigne-24,nb[0]/nbLigne),
A2(nbLigne-24,nb[0]/nbLigne),sig3(nbLigne-24,nb[0]/nbLigne),
A3(nbLigne-24,nb[0]/nbLigne),sig4(nbLigne-24,nb[0]/nbLigne),
A4(nbLigne-24,nb[0]/nbLigne),sig5(nbLigne-24,nb[0]/nbLigne),
A5(nbLigne-24,nb[0]/nbLigne),sig6(nbLigne-24,nb[0]/nbLigne),
A6(nbLigne-24,nb[0]/nbLigne),sig7(nbLigne-24,nb[0]/nbLigne),
A7(nbLigne-24,nb[0]/nbLigne),sig8(nbLigne-24,nb[0]/nbLigne),
A8(nbLigne-24,nb[0]/nbLigne),sig9(nbLigne-24,nb[0]/nbLigne),
A9(nbLigne-24,nb[0]/nbLigne),sig10(nbLigne-24,nb[0]/nbLigne),
B[10],NewBase[10],Somme[10],ImgTot(nbLigne-24,10),NewImg1(nbLigne-24,nb[0]/nbLigne),
NewImg2(nbLigne-24,nb[0]/nbLigne),NewImg3(nbLigne-24,nb[0]/nbLigne),
NewImg4(nbLigne-24,nb[0]/nbLigne),NewImg5(nbLigne-24,nb[0]/nbLigne),
NewImg6(nbLigne-24,nb[0]/nbLigne),NewImg7(nbLigne-24,nb[0]/nbLigne),
NewImg8(nbLigne-24,nb[0]/nbLigne),NewImg9(nbLigne-24,nb[0]/nbLigne),
NewImg10(nbLigne-24,nb[0]/nbLigne),D(6,1);
//les colonnes de BaseDeb
B[0].in(BaseDeb0);
B[1].in(BaseDeb1);
B[2].in(BaseDeb2);
B[3].in(BaseDeb3);
B[4].in(BaseDeb4);
B[5].in(BaseDeb5);
B[6].in(BaseDeb6);
B[7].in(BaseDeb7);
B[8].in(BaseDeb8);
B[9].in(BaseDeb9);
 
//la base surlaquelle on va fiar el'orthogonolistaion des images brutes
NewBase[0].in(BaseDeb0);
Somme[0].zeros();
Somme[1].zeros();
 
for(int i =1;i<10;i++)
{
for(int j=0;j<i;j++)
Somme=Somme+((NewBase[j]*(((B.transpose1())*NewBase[j])))/(pow(NewBase[j].norm(),2)));
//cout<<"Somme["<<i<<"]="<<endl;
//cout<<Somme<<endl;
 
NewBase=B-Somme;
//cout<<"NewBase["<<i<<"]="<<endl;
//cout<<NewBase<<endl;
}
 
for(int i =1;i<10;i++)
{
(B.transpose1()).destroy();
B.destroy();
Somme.destroy();
}
 
//remplissage des matrices
A0.in(data0);
A1.in(data1);
A2.in(data2);
A3.in(data3);
A4.in(data4);
A5.in(data5);
A6.in(data6);
A7.in(data7);
A8.in(data8);
A9.in(data9);
 
delete [] data0;
delete [] data1;
delete [] data2;
delete [] data3;
delete [] data4;
delete [] data5;
delete [] data6;
delete [] data7;
delete [] data8;
delete [] data9;
 
//moyenne des matrices
/*A1=A0.mean();
A3=A2.mean();*/
 
 
//Images aller et retour
sig1=A0-c.ones()*A0.mean();
//cout<<"sig1="<<sig1<<endl;
 
sig2=A1-c.ones()*A1.mean();
//cout<<"sig2="<<sig2<<endl;
 
sig3=A2-c.ones()*A2.mean();
//cout<<"sig3="<<sig3<<endl;
 
sig4=A3-c.ones()*A3.mean();
//cout<<"sig4="<<sig4<<endl;
 
sig5=A4-c.ones()*A4.mean();
//cout<<"sig5="<<sig5<<endl;
 
sig6=A5-c.ones()*A5.mean();
//cout<<"sig6="<<sig6<<endl;
 
sig7=A6-c.ones()*A6.mean();
//cout<<"sig7="<<sig7<<endl;
 
sig8=A7-c.ones()*A7.mean();
//cout<<"sig8="<<sig8<<endl;
 
sig9=A8-c.ones()*A8.mean();
//cout<<"sig9="<<sig9<<endl;
 
sig10=A9-c.ones()*A9.mean();
cout<<"sig10="<<sig10<<endl;
//Libérer la memoire
A0.destroy();
A1.destroy();
A2.destroy();
A3.destroy();
A4.destroy();
A5.destroy();
A6.destroy();
A7.destroy();
A8.destroy();
A9.destroy();
 
/*cout<<"sig10="<<endl;
cout<<sig10<<endl;*/
 
for(int i =0;i<nb[0]/nbLigne;i++)
{
ImgTot.fill(sig1.colonne(i),0);
ImgTot.fill(sig2.colonne(i),1);
ImgTot.fill(sig3.colonne(i),2);
ImgTot.fill(sig4.colonne(i),3);
ImgTot.fill(sig5.colonne(i),4);
ImgTot.fill(sig6.colonne(i),5);
ImgTot.fill(sig7.colonne(i),6);
ImgTot.fill(sig8.colonne(i),7);
ImgTot.fill(sig9.colonne(i),8);
ImgTot.fill(sig10.colonne(i),9);
 
/*for(int i =0;i<nb[0]/nbLigne;i++)
cout<<"IMgTot["<<i<<"]="<<endl;*/
//cout<<ImgTot<<endl;
NewImg1.fill(ImgTot*NewBase[0],i);
//NewImg2.fill(ImgTot*NewBase[1],i);
/*NewImg3.fill(ImgTot*NewBase[2],i);
NewImg4.fill(ImgTot*NewBase[3],i);
NewImg5.fill(ImgTot*NewBase[4],i);
NewImg6.fill(ImgTot*NewBase[5],i);
NewImg7.fill(ImgTot*NewBase[6],i);
NewImg8.fill(ImgTot*NewBase[7],i);
NewImg9.fill(ImgTot*NewBase[8],i);
NewImg10.fill(ImgTot*NewBase[9],i);*/
}
//cout<<"NewImg10="<<endl;
//cout<<NewImg2<<endl;
cout<<"IMgTot[]="<<endl;
cout<<ImgTot<<endl;
for (int j=0;j<nbligne;j++)
cout <<"nb["<<j<<"]="<<nb[j]<<endl;
cout <<"nbLigne="<<nbLigne<<endl;
for(int i =1;i<10;i++)
NewBase.destroy();
ImgTot.destroy();
//NewImg2.destroy();
sig1.destroy();
sig2.destroy();
sig3.destroy();
sig4.destroy();
sig5.destroy();
sig6.destroy();
sig7.destroy();
sig8.destroy();
sig9.destroy();
sig10.destroy();
}
 
int fonction ()
{
 
ifstream fichier( "image_aller_0.txt" );
 
 
if ( fichier ) // ce test échoue si le fichier n'est pas ouvert
{
string lign;// variable contenant chaque ligne lue
while ( getline( fichier, lign,'\n') )
{
nbLigne++;
}
cout<<"le nombre des lignes ="<<nbLigne<<endl;
}
return nbLigne;
}