#include <stdlib.h>
#include <math.h>
#include "image.h"
#include "grille.h"
#include "visu.h"
#include "fourier.h"
#include "c.h"
#include "r.h"
#include "o.h"


Image   TransfereO(Image imS, Image imD)
/***************************************/

{
Canal canL,canE;
Octet *valeur;
int x,y,i;

if ( (imD=CreeImageDest(imS, imD, T_OCTET))==NULL) return(NULL);

if (imD==imS) return(imD);

LitTailleFenetre(imD,&x, &y);
if ((valeur=(Octet *)calloc(x,sizeof(Octet)))==NULL) return(NULL);
if ((canL=CreeCanal(imS, T_OCTET, B_LIGNE, Z_FENETRE))==NULL) return(NULL);
if ((canE=CreeCanal(imD, T_OCTET, B_LIGNE, Z_FENETRE))==NULL) return(NULL);

for (i=0;i<y;i++)
   {
   LitCanal(canL, valeur);
   EcritCanal(canE, valeur);
   }

free(valeur);
LibereCanal(canL);
LibereCanal(canE);
return (imD) ;
}



Image  VisuReelLO ( Image imS, Image imD )
/****************************************/

{
Canal canL,canE;
ReelL *valeur,min,max;
ReelL a,b,val;
Octet *valdest;
InfoCarte info;
int x,y,i,j;

if (imS==NULL) return(NULL);
if (imS->info==NULL) return(NULL);
if ( (imD=CreeImageDest(imS, imD, T_OCTET))==NULL) return(NULL);

LitTailleFenetre(imD,&x, &y);
if ((valeur=(ReelL *)calloc(x,sizeof(ReelL)))==NULL) return(NULL);
if ((valdest=(Octet *)calloc(x,sizeof(Octet)))==NULL) return(NULL);
if ((canL=CreeCanal(imS, T_REELL, B_LIGNE, Z_FENETRE))==NULL) return(NULL);
if ((canE=CreeCanal(imD, T_OCTET, B_LIGNE, Z_FENETRE))==NULL) return(NULL);

info = (InfoCarte)(imS->info);
min = info->eMin;
max = info->eMax;

a = min;
b = 255.0 / ( max - min );
for (i=0;i<y;i++)
   {
   LitCanal(canL, valeur);
   for (j=0;j<x;j++)
      {
		val=(valeur[j] - a) * b;
      if (val>255) val=255;
      if (val<0) val=0;
      valdest[j] = (unsigned char)val;
      }
   EcritCanal(canE, valdest);
   }

free(valeur);
LibereCanal(canL);
LibereCanal(canE);
return (imD) ;
}


Image ComprimYO(Image imS, Image imD, double coef)
/***************************************************/

{
int i,j,x,y,y1,i1,i2;
Canal canL,canE;
double a,b1,b2;
Octet *val1,*val2;

if (imS==NULL) return(NULL);
LitTailleFenetre(imS,&x,&y);
if (y<=1) return(NULL);

y1=(int)(y*coef);

if ((imD=CreeImageSimple(imD,T_OCTET,imS->visu,x,y))==NULL) return(NULL);

if ((val1=(Octet *)calloc(x,sizeof(Octet)))==NULL) return(NULL);
if ((val2=(Octet *)calloc(x,sizeof(Octet)))==NULL) return(NULL);
if ((canL=CreeCanal(imS,T_OCTET,B_LIGNE,Z_FENETRE))==NULL) return(NULL);
if ((canE=CreeCanal(imD,T_OCTET,B_LIGNE,Z_FENETRE))==NULL) return(NULL);

LitCanal(canL,val1);
EcritCanal(canE,val1);
for (i=1; i<y1;i++)
    {
    a = i/coef;
    i1 = (int)a;
    i2 = i1 + 1;
    b1 = i2 - a;
    b2 = a - i1;
    PoseCanal(canL,0,i1);
    LitCanal(canL,val1);
    LitCanal(canL,val2);
	 for (j=0; j<x; j++)
        val1[j] = (Octet)( b1 * val1[j] + b2 * val2[j] );
    EcritCanal(canE,val1);
    }

for (j=0; j<x; j++) val1[j]=0;
for (i=y1;i<y; i++) EcritCanal(canE,val1);

LibereCanal(canE);
LibereCanal(canL);
free(val2);
free(val1);
return(imD);
}


Image NiveauO(Image imS, Image imD, Octet valeur)
/***********************************************/

{
Canal canE;
Octet *tampon;
int x,y,i;

if ( (imD=CreeImageDest(imS, imD, T_OCTET))==NULL) return(NULL);

LitTailleFenetre(imD,&x, &y);
if ((tampon=(Octet *)calloc(x,sizeof(Octet)))==NULL) return(NULL);
if ((canE=CreeCanal(imD, T_OCTET, B_LIGNE, Z_FENETRE))==NULL) return(NULL);

for (i=0;i<x;i++) tampon[i]=valeur;
for (i=0;i<y;i++) EcritCanal(canE,tampon);

LibereCanal(canE);
free(tampon);
return(imD);
}



Image ExtraitFenetreO(Image imS, Image imD)
/******************************************/

{
int i,x,y;
Canal canL,canE;
Octet *val;

if (imS==NULL) return(NULL);
LitTailleFenetre(imS,&x,&y);

if ((imD=CreeImageSimple(imD,T_OCTET,imS->visu,x,y))==NULL) return(NULL);
if (imS->lut!=NULL) if (EcritLut(imD,imS->lut->taille,imS->lut->table)) return(NULL);

if ((val=(Octet*)calloc(x,sizeof(Octet)))==NULL) return(NULL);
if ((canL=CreeCanal(imS,T_OCTET,B_LIGNE,Z_FENETRE))==NULL) return(NULL);
if ((canE=CreeCanal(imD,T_OCTET,B_LIGNE,Z_FENETRE))==NULL) return(NULL);

for (i=0;i<y;i++)
	 {
    LitCanal(canL,val);
    EcritCanal(canE,val);
    }


LibereCanal(canE);
LibereCanal(canL);
free(val);
return(imD);
}


Image  SoustrO ( Image imS1, Image imS2, Image imD )
/**************************************************/

{
Canal canL1, canL2, canE;
Octet *valeur1, *valeur2;
int i, j, x, y;

if ((imD = CreeImageDest (imS1, imD, T_OCTET)) == NULL)  return (NULL);
if (TesteFenetre(imS2, imD)) return (NULL);

LitTailleFenetre (imD, &x, &y);

if ((valeur1 = (Octet *)calloc(x,sizeof(Octet))) ==  NULL)  return (NULL);
if ((valeur2 = (Octet *)calloc(x,sizeof(Octet))) ==  NULL)  return (NULL);
if ((canL1 = CreeCanal (imS1, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);
if ((canL2 = CreeCanal (imS2, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);
if ((canE = CreeCanal (imD, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);

for (i=0; i<y; i++)
     {
     LitCanal (canL1, valeur1);
     LitCanal (canL2, valeur2);
	  for (j=0; j<x; j++)
		  valeur1[j] =(Octet)( 128 + valeur1[j]/2 - valeur2[j]/2);
     EcritCanal (canE, valeur1);
     }

LibereCanal(canE);
LibereCanal(canL2);
LibereCanal(canL1);
free(valeur2);
free(valeur1);
return (imD);
}



Image  SoustrAbsO ( Image imS1, Image imS2, Image imD )
/*****************************************************/

{
Canal canL1, canL2, canE;
Octet *valeur1, *valeur2;
int i, j, x, y, a;

if ((imD = CreeImageDest (imS1, imD, T_OCTET)) == NULL)  return (NULL);
if (TesteFenetre(imS2, imD)) return (NULL);

LitTailleFenetre (imD, &x, &y);

if ((valeur1 = (Octet *)calloc(x,sizeof(Octet))) ==  NULL)  return (NULL);
if ((valeur2 = (Octet *)calloc(x,sizeof(Octet))) ==  NULL)  return (NULL);
if ((canL1 = CreeCanal (imS1, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);
if ((canL2 = CreeCanal (imS2, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);
if ((canE = CreeCanal (imD, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);

for (i=0; i<y; i++)
     {
	  LitCanal (canL1, valeur1);
     LitCanal (canL2, valeur2);
     for (j=0; j<x; j++)
		  if ((a = (int)valeur1[j] - (int)valeur2[j]) > 0)  valeur1[j] =(Octet) a;
	  else  valeur1[j] = (Octet)-a;
     EcritCanal(canE, valeur1);
     }

LibereCanal(canE);
LibereCanal(canL2);
LibereCanal(canL1);
free(valeur2);
free(valeur1);
return (imD);
}



Image  AddO ( Image imS1, Image imS2, Image imD )
/***********************************************/

{
Canal canL1, canL2, canE;
Octet *valeur1, *valeur2;
int i, j, x, y;

if ((imD = CreeImageDest (imS1, imD, T_OCTET)) == NULL)  return (NULL);
if (TesteFenetre(imS2, imD)) return (NULL);

LitTailleFenetre (imD, &x, &y);

if ((valeur1 = (Octet *)calloc(x,sizeof(Octet))) ==  NULL)  return (NULL);
if ((valeur2 = (Octet *)calloc(x,sizeof(Octet))) ==  NULL)  return (NULL);
if ((canL1 = CreeCanal (imS1, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);
if ((canL2 = CreeCanal (imS2, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);
if ((canE = CreeCanal (imD, T_OCTET, B_LIGNE, Z_FENETRE)) == NULL)  return (NULL);

for (i=0; i<y; i++)
     {
     LitCanal (canL1, valeur1);
     LitCanal (canL2, valeur2);
     for (j=0; j<x; j++)
          valeur1[j] =(Octet)( valeur1[j]/2 + valeur2[j]/2);
     EcritCanal (canE, valeur1);
     }

LibereCanal(canE);
LibereCanal(canL2);
LibereCanal(canL1);
free(valeur2);
free(valeur1);
return (imD);
}


/**-------------------------------------------------**/

Image OuBinaireO ( Image imaS1, Image imaS2, Image imaD)

{
Canal   canLS1,canLS2;	// canal des images sources
Octet    **grille;	// grille d'accès à l'image destination
Octet	*tab1,*tab2;	// tableau du canal des images sources
int	x,y;		// dimension de la fenetre à traiter
int	i,j;

if (TesteFenetre(imaS1,imaS2)) return(NULL);

LitTailleFenetre (imaS1,&x,&y);     // taille de la fenetre source

if ( (imaD=CreeImageDest(imaS1,imaD,T_OCTET)) == NULL)
	return(NULL);

if ( (canLS1=CreeCanal(imaS1,T_OCTET,B_LIGNE,Z_FENETRE)) == NULL)
	{  return(NULL);}
if ( (canLS2=CreeCanal(imaS2,T_OCTET,B_LIGNE,Z_FENETRE)) == NULL)
	{ LibereCanal(canLS1); return(NULL);}

if (( tab1 = (Octet*)calloc(x,sizeof(Octet))) == NULL) {
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}
if (( tab2 = (Octet*)calloc(x,sizeof(Octet))) == NULL) {
	free(tab1);
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}
if ( (grille=(Octet**)CreeGrille(imaD,Z_FENETRE)) == NULL) {
	free(tab2); free(tab1);
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}

for (i=0;i<y;i++)
	 {
	 LitCanal(canLS1,tab1);
	 LitCanal(canLS2,tab2);
	 for (j=0;j<x;j++)  grille[i][j] = tab1[j] | tab2[j];
	 }

LibereGrille(grille);
free(tab2); free(tab1);
LibereCanal(canLS2);LibereCanal(canLS1);

return(imaD);
}

//-----------------------------------------------------------

Image OuExBinaireO ( Image imaS1, Image imaS2, Image imaD)

{
Canal   canLS1,canLS2;	// canal des images sources
Octet    **grille;	// grille d'accès à l'image destination
Octet	*tab1,*tab2;	// tableau du canal des images sources
int	x,y;		// dimension de la fenetre à traiter
int	i,j;

if (TesteFenetre(imaS1,imaS2)) return(NULL);

LitTailleFenetre (imaS1,&x,&y);     // taille de la fenetre source

if ( (imaD=CreeImageDest(imaS1,imaD,T_OCTET)) == NULL)
	return(NULL);

if ( (canLS1=CreeCanal(imaS1,T_OCTET,B_LIGNE,Z_FENETRE)) == NULL)
	{  return(NULL);}
if ( (canLS2=CreeCanal(imaS2,T_OCTET,B_LIGNE,Z_FENETRE)) == NULL)
	{ LibereCanal(canLS1); return(NULL);}
if (( tab1 = (Octet*)calloc(x,sizeof(Octet))) == NULL) {
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}
if (( tab2 = (Octet*)calloc(x,sizeof(Octet))) == NULL) {
	free(tab1);
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}
if ( (grille=(Octet**)CreeGrille(imaD,Z_FENETRE)) == NULL) {
	free(tab2); free(tab1);
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}

for (i=0;i<y;i++)
	 {
	 LitCanal(canLS1,tab1);
	 LitCanal(canLS2,tab2);
	 for (j=0;j<x;j++)  grille[i][j] = tab1[j] ^ tab2[j];
	 }

LibereGrille(grille);
free(tab2); free(tab1);
LibereCanal(canLS2);LibereCanal(canLS1);

return(imaD);
}


/**-------------------------------------------------**/

Image EtBinaireO ( Image imaS1, Image imaS2, Image imaD)

{
Canal   canLS1,canLS2;	// canal des images sources
Octet    **grille;	// grille d'accès à l'image destination
Octet	*tab1,*tab2;	// tableau du canal des images sources
int	x,y;		// dimension de la fenetre à traiter
int	i,j;

if (TesteFenetre(imaS1,imaS2)) return(NULL);

LitTailleFenetre (imaS1,&x,&y);     // taille de la fenetre source

if ( (imaD=CreeImageDest(imaS1,imaD,T_OCTET)) == NULL)
	return(NULL);

if ( (canLS1=CreeCanal(imaS1,T_OCTET,B_LIGNE,Z_FENETRE)) == NULL)
	{  return(NULL);}
if ( (canLS2=CreeCanal(imaS2,T_OCTET,B_LIGNE,Z_FENETRE)) == NULL)
	{ LibereCanal(canLS1); return(NULL);}

if (( tab1 = (Octet*)calloc(x,sizeof(Octet))) == NULL) {
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}
if (( tab2 = (Octet*)calloc(x,sizeof(Octet))) == NULL) {
	free(tab1);
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}
if ( (grille=(Octet**)CreeGrille(imaD,Z_FENETRE)) == NULL) {
	free(tab2); free(tab1);
	LibereCanal(canLS2);LibereCanal(canLS1);
	 return(NULL);
	}

for (i=0;i<y;i++)
	 {
	 LitCanal(canLS1,tab1);
	 LitCanal(canLS2,tab2);
	 for (j=0;j<x;j++)  grille[i][j] = tab1[j] & tab2[j];
	 }

LibereGrille(grille);
free(tab2); free(tab1);
LibereCanal(canLS2);LibereCanal(canLS1);

return(imaD);
}

Image OperTableO(Image imS, Image table, Image imD)
/*************************************************/

{
Canal canL;
Octet **grille;
Octet *val,*t;
int i,j,x,y,n,yn;

if (table==NULL) return(NULL);
LitTailleFenetre(table,&n,&yn);
if (yn>1) return(NULL);
if (n!=256) return(NULL);
if ((imD=CreeImageDest(imS,imD,T_OCTET))==NULL) return(NULL);
LitTailleFenetre(imS,&x,&y);
if ((val=(Octet *)calloc(x,sizeof(Octet)))==NULL) return(NULL);
if ((t=(Octet *)calloc(n,sizeof(Octet)))==NULL) return(NULL);

if ((canL=CreeCanal(table,T_OCTET,B_LIGNE,Z_FENETRE))==NULL) return(NULL);
LitCanal(canL,t);
LibereCanal(canL);

if ((canL=CreeCanal(imS,T_OCTET,B_LIGNE,Z_FENETRE))==NULL) return(NULL);
if ((grille=(Octet**) CreeGrille(imD,Z_FENETRE))==NULL) return(NULL);

for (i=0;i<y;i++)
    {
    LitCanal(canL,val);
    for (j=0;j<x;j++) grille[i][j]=t[val[j]];
    }

LibereGrille(grille);
LibereCanal(canL);
free(t);
free(val);
return(imD);
}


/*-----------------------------------------------------------------*/

Image TraceDroiteO(Image imS, int x1, int y1, int x2, int y2,Octet valeur, int oper)
/**********************************************************************************/
{
int x, y, dx, d2x, dy, d2y, s1, s2, aux, e, interchange = 0;
int xs,ys;
Canal canL;
Octet val;

if (imS==NULL) return(NULL);
LitTailleFenetre(imS,&xs,&ys);
if ( (x1<0) || (x1>=xs) || (y1<0) || (y1>=ys) ) return(NULL);
if ( (x2<0) || (x2>=xs) || (y2<0) || (y2>=ys) ) return(NULL);

dx = abs (x2-x1);
dy = abs (y2-y1);
s1 = (x2>x1) ? 1 : ((x2<x1) ? -1 : 0);
s2 = (y2>y1) ? 1 : ((y2<y1) ? -1 : 0);
x = x1;
y = y1;


 if (dy > dx)
  {
	aux = dx;
	dx = dy;
	dy = aux;
	interchange = 1;
  }

 d2x = 2*dx;
 d2y = 2*dy;
 e = d2y-dx;


 if ((canL=CreeCanal(imS,T_OCTET,B_POINT,Z_FENETRE))==NULL) return(NULL);



 if (interchange)
  {

	if (s2 >0)
	 {
		for (y=y1; y<=y2; y++)
		  {

	PoseCanal(canL,x,y);
	LitCanal(canL,&val);
	 val=oper?val^valeur:valeur;
	PoseCanal(canL,x,y);
	EcritCanal(canL,&val);
	if (e >= 0)
	  {
		x += s1;
		e -= d2x;
	  }
	e += d2y;

		 }
	 }
	else  for (y=y1; y>=y2; y--)
		  {

	PoseCanal(canL,x,y);
	LitCanal(canL,&val);
	 val=oper?val^valeur:valeur;
	PoseCanal(canL,x,y);
	EcritCanal(canL,&val);
	if (e >= 0)
	  {
		x += s1;
		e -= d2x;
	  }
	e += d2y;

		  }
 }
 else {

		 if (s1>0)  for (x=x1; x<=x2; x++)
							  {

	PoseCanal(canL,x,y);
	LitCanal(canL,&val);
	 val=oper?val^valeur:valeur;
	PoseCanal(canL,x,y);
	EcritCanal(canL,&val);
	  if (e >= 0)
		 {
		  y += s2;
		  e -= d2x;
		 }
		e += d2y;

							  }
		 else for (x=x1; x>=x2; x--)
								{

	PoseCanal(canL,x,y);
	LitCanal(canL,&val);
	 val=oper?val^valeur:valeur;
	PoseCanal(canL,x,y);
	EcritCanal(canL,&val);
	  if (e >= 0)
		 {
		  y += s2;
		  e -= d2x;
		 }
		e += d2y;

								}
		}

LibereCanal(canL);

return(imS);
}




Image TraceVecteurO(Image imP,Image imS,Image imD,Octet cPoint,Octet cTrait1,Octet cTrait2,int fleche)
/****************************************************************************************************/
{
int j,n,ox,oy,tx,ty;
Complexe **grille;
Complexe fleche1,fleche2;
Octet **grilleO,coul[2];
Reel x,y;

if (imP==NULL) return(NULL);
if (imS==NULL) return(NULL);
if ((imP->visu!=V_POINT)||(imP->type!=T_COMPLEXE)||(imP->fenetre.taille.y<2)) return(NULL);
n=imP->fenetre.taille.x;

if ((imD=CreeImageDest(imS,imD,T_OCTET))==NULL) return(NULL);
if ((grille=(Complexe**)CreeGrille(imP,Z_FENETRE))==NULL) return(NULL);
if ((grilleO=(Octet**)CreeGrille(imD,Z_FENETRE))==NULL) return(NULL);
LitFenetre (imD,&ox,&oy,&tx,&ty);
coul[0]=cTrait1;
coul[1]=cTrait2;
for (j=0;j<n;j++)
		{
		if ((grille[0][j].x<ox+tx)&&(grille[0][j].x>ox)&&(grille[0][j].y<oy+ty)&&(grille[0][j].y>oy))
			{
			x=grille[0][j].x-ox;
			y=grille[0][j].y-oy;
			TraceDroiteO(imD,x,y,x+grille[1][j].x,y+grille[1][j].y,coul[j%2],1);
			if (fleche==1)
				{
				fleche1.x=(x+grille[1][j].x)-((grille[1][j].x*0.707-grille[1][j].y*0.707)*0.4);
				fleche1.y=(y+grille[1][j].y)-((grille[1][j].x*0.707+grille[1][j].y*0.707)*0.4);
				if (fleche1.x>0) fleche1.x=(int)(fleche1.x+0.5);
				else fleche1.x=(int)(fleche1.x-0.5);
				if (fleche1.y>0) fleche1.y=(int)(fleche1.y+0.5);
				else fleche1.y=(int)(fleche1.y-0.5);

				fleche2.x=(x+grille[1][j].x)-((grille[1][j].x*0.707+grille[1][j].y*0.707)*0.4);
				fleche2.y=(y+grille[1][j].y)-((-grille[1][j].x*0.707+grille[1][j].y*0.707)*0.4);
				if (fleche2.x>0) fleche2.x=(int)(fleche2.x+0.5);
				else fleche2.x=(int)(fleche2.x-0.5);
				if (fleche2.y>0) fleche2.y=(int)(fleche2.y+0.5);
				else fleche2.y=(int)(fleche2.y-0.5);

				TraceDroiteO(imD,x+grille[1][j].x,y+grille[1][j].y,fleche1.x,fleche1.y,coul[j%2],0);
				TraceDroiteO(imD,x+grille[1][j].x,y+grille[1][j].y,fleche2.x,fleche2.y,coul[j%2],0);
				}
			grilleO[(int)grille[0][j].y-oy][(int)grille[0][j].x-ox]=cPoint;
			}
		}
LibereGrille(grilleO);
LibereGrille(grille);
return(imD);
}



Image DeplCorrelO(Image imS1,Image imS2,Image imD)
/************************************************/
{
int i,n,x,y,ox,oy;
Image imCorrelation;
FenetreL fenetreL,fen;

if ((imS1==NULL)||(imS2==NULL)) return(NULL);
if (TesteFenetre(imS1,imS2)) return(NULL);
n=CompteFenetreL(imS1->fenetreL);
if (n==0) return(NULL);
if ((imD=CreeImageDest (imS1,imD,T_OCTET))==NULL) return (NULL);
imCorrelation=CorreleC(imS1,imS2,NULL);
//insertion de la liste de fenetre dans imCorrelation
LitFenetre(imCorrelation,&ox,&oy,&x,&y);
for (i=0;i<n;i++)
	{
	fen=LitFenetreL(imS1->fenetreL,i);
	fenetreL=CreeFenetreL(fen->origine.x,fen->origine.y,fen->taille.x,fen->taille.y);
	InsereFenetreL(&imCorrelation->fenetreL,fenetreL,i);
	}
EcritFenetre(imCorrelation,ox,oy,x,y);
EcritFenetre(imD,ox,oy,x,y);
imD->suivant=DepouilleCorrelC(imCorrelation,imD->suivant);
if(imD->suivant!=NULL)
	{
	LitFenetre(imD->suivant,&ox,&oy,&x,&y);
	if (x>1) EcritFenetre (imD->suivant,0,0,1,2);
	imD=TraceVecteurO(imD->suivant,imS1,imD,118,186,255,1);
	if (ox+1<n) EcritFenetre(imD->suivant,ox+1,0,1,2);
	}
LibereImage(imCorrelation);
return (imD);
}


//Image DeplCorrelDirO(Image imS1,Image imS2,Image imD,Reel reducX,Reel reducY)
/*****************************************************************************/
/*{
int i,n,x,y,ox,oy;
Image imCorrelation;
FenetreL fenetreL,fen;

if ((imS1==NULL)||(imS2==NULL)) return(NULL);
if (TesteFenetre(imS1,imS2)) return(NULL);
n=CompteFenetreL(imS1->fenetreL);
if (n==0) return(NULL);
if ((imD=CreeImageDest (imS1,imD,T_OCTET))==NULL) return (NULL);
imCorrelation=CorrelDirecteR(imS1,imS2,NULL,reducX,reducY);
//insertion de la liste de fenetre dans imCorrelation
LitFenetre(imCorrelation,&ox,&oy,&x,&y);
for (i=0;i<n;i++)
	{
	fen=LitFenetreL(imS1->fenetreL,i);
	fenetreL=CreeFenetreL(fen->origine.x,fen->origine.y,fen->taille.x,fen->taille.y);
	InsereFenetreL(&imCorrelation->fenetreL,fenetreL,i);
	}
EcritFenetre (imCorrelation,ox,oy,x,y);
EcritFenetre (imD,ox,oy,x,y);
imD->suivant=DepouilleCorrelC(imCorrelation,imD->suivant);
if(imD->suivant!=NULL)
	{
	LitFenetre(imD->suivant,&ox,&oy,&x,&y);
	if (x>1) EcritFenetre (imD->suivant,0,0,1,2);
	imD=TraceVecteurO(imD->suivant,imD,imD,118,186,255,1);
	if (ox+1<n) EcritFenetre(imD->suivant,ox+1,0,1,2);
	}
LibereImage(imCorrelation);
return (imD);
}
*/
//Image DeplAutoCorrelO(Image imS,Image imD)
/****************************************/
/*{
int i,n,x,y,ox,oy;
Image imCorrelation;
FenetreL fenetreL,fen;

if (imS==NULL) return(NULL);
n=CompteFenetreL(imS->fenetreL);
if (n==0) return(NULL);
if ((imD=CreeImageDest (imS,imD,T_OCTET))==NULL) return (NULL);
imCorrelation=AutoCorreleC(imS,NULL);
//insertion de la liste de fenetre dans imCorrelation
LitFenetre(imCorrelation,&ox,&oy,&x,&y);
for (i=0;i<n;i++)
	{
	fen=LitFenetreL(imS->fenetreL,i);
	fenetreL=CreeFenetreL(fen->origine.x,fen->origine.y,fen->taille.x,fen->taille.y);
	InsereFenetreL(&imCorrelation->fenetreL,fenetreL,i);
	}
EcritFenetre(imCorrelation,ox,oy,x,y);
EcritFenetre(imD,ox,oy,x,y);
imD->suivant=DepouilleAutoCorrelC(imCorrelation,imD->suivant);
if(imD->suivant!=NULL)
	{
	LitFenetre(imD->suivant,&ox,&oy,&x,&y);
	if (x>1) EcritFenetre (imD->suivant,0,0,1,2);
	imD=TraceVecteurO(imD->suivant,imS,imD,118,186,255,0);
	if (ox+1<n) EcritFenetre(imD->suivant,ox+1,0,1,2);
	}
LibereImage(imCorrelation);
return (imD);
}
*/
//Image DeplAutoCorrelDirO(Image imS,Image imD,Reel reducX,Reel reducY)
/********************************************************************/
/*{
int i,n,x,y,ox,oy;
Image imCorrelation,imAlias;
FenetreL fenetreL,fen;

if (imS==NULL) return(NULL);
n=CompteFenetreL(imS->fenetreL);
if (n==0) return(NULL);
if ((imD=CreeImageDest (imS,imD,T_OCTET))==NULL) return (NULL);
if ((imAlias=(Image)calloc (1,sizeof (*imAlias)))==NULL) return( NULL);
*imAlias=*imS;
imCorrelation=CorrelDirecteR(imS,imAlias,NULL,reducX,reducY);
//insertion de la liste de fenetre dans imCorrelation
LitFenetre(imCorrelation,&ox,&oy,&x,&y);
for (i=0;i<n;i++)
	{
	fen=LitFenetreL(imS->fenetreL,i);
	fenetreL=CreeFenetreL(fen->origine.x,fen->origine.y,fen->taille.x,fen->taille.y);
	InsereFenetreL(&imCorrelation->fenetreL,fenetreL,i);
	}
EcritFenetre(imCorrelation,ox,oy,x,y);
EcritFenetre(imD,ox,oy,x,y);
imD->suivant=DepouilleAutoCorrelC(imCorrelation,imD->suivant);
if(imD->suivant!=NULL)
	{
	LitFenetre(imD->suivant,&ox,&oy,&x,&y);
	if (x>1) EcritFenetre (imD->suivant,0,0,1,2);
	imD=TraceVecteurO(imD->suivant,imD,imD,118,186,255,0);
	if (ox+1<n) EcritFenetre(imD->suivant,ox+1,0,1,2);
	}
LibereImage(imCorrelation);
free (imAlias);
return (imD);
}
*/

int EcritVecteurO (Image image,FILE *text)
/****************************************/
{
int i,n,ox,oy,tx,ty;
Complexe **grille;

if ((image==NULL)||(image->suivant==NULL)||(text==NULL)) return (1);
if ((image->suivant->visu!=V_POINT)||(image->suivant->type!=T_COMPLEXE)) return (1);
LitTailleImage (image->suivant,&tx,&ty);
n=tx;
EcritFenetre(image->suivant,0,0,tx,ty);
LitFenetre (image,&ox,&oy,&tx,&ty);
if ((grille=(Complexe**)CreeGrille(image->suivant,Z_FENETRE))==NULL) return (1);
if (image->fenetreL!=NULL)
	{
	i=0;
	while (((grille[0][i].x!=ox+tx/2)||(grille[0][i].y!=oy+ty/2))&&(i<n)) i++;
	if (i==0) fprintf (text,"\t%g \t %g \t %g \t %g \n",grille[0][i].x,grille[0][i].y,grille[1][i].x,grille[1][i].y);
	else fprintf (text,"\t\t\t%g \t %g \t %g \t %g \n",grille[0][i].x,grille[0][i].y,grille[1][i].x,grille[1][i].y);
	}
else
	{
	i=0;
	fprintf (text,"\t%g \t %g \t %g \t %g \n",grille[0][i].x,grille[0][i].y,grille[1][i].x,grille[1][i].y);
	for (i=1;i<n;i++)
		fprintf (text,"\t\t\t%g \t %g \t %g \t %g \n",grille[0][i].x,grille[0][i].y,grille[1][i].x,grille[1][i].y);
	}
LibereGrille (grille);
return (0);
}


