/*********************************Array Bidimensional***************************/



#include<iostream.h>
#include<fstream.h>
#include<stdlib.h>
#include <math.h>

/***********************************clase imagen**************************************/

class Imagen

{
friend ostream &operator<<(ostream& salida, const Imagen &imag);

public:

		int Filas,Columnas;
		unsigned char**Punt;

		void ReservaMemoria(int fil,int col);
		void LiberaMemoria();




public:

		unsigned char getvalor(int i,int j){return Punt[i][j];}
		int getfilas(void){return Filas;}
		int getcolumnas(void){return Columnas;}
		void CreaImagen(int fil,int col);
		Imagen& operator=(const Imagen&imag);
		Imagen& operator=(const int valor);
		
		void IntroduceElementos(int valor,int fil,int col);
		void PideElementos ();
		void ImagenTranspuesta ();
		void Raiz ();
		void Cuadrado ();
		void Anniade (Imagen & obj);
		void Visualiza();
	




		Imagen(int fil=0,int col=0);

		Imagen(const Imagen&imag);

		~Imagen();








};

/************************		Constructores & Destructores		************************/

Imagen::Imagen(int fil,int col)
{


	Punt=NULL;
	Filas=fil;
	Columnas=col;
	CreaImagen(fil,col);

}

Imagen::Imagen(const Imagen&imag)
{

	int i,j;

	if(imag.Punt!=NULL)
	{
		Filas=imag.Filas;
		Columnas=imag.Columnas;

		CreaImagen(Filas,Columnas);

		for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
				Punt[i][j]=imag.Punt[i][j];

	}
}

Imagen::~Imagen()

{
		LiberaMemoria();
}





/*****************		Funciones miembro		************************/

void Imagen::ReservaMemoria(int fil,int col)
{

	int f;
	Filas=fil;
	Columnas=col;




	if(Filas!=0 && Columnas!=0)
	{
		Punt=new unsigned char*[Filas];

		for(f=0;f<Filas;f++)
		{
				Punt[f]=new unsigned char[Columnas];

		};
	}

}

void Imagen::LiberaMemoria()

{

	int i;


	if(Punt!=NULL)
	{
		{

			for(i=0;i<Filas;i++)
				delete[]Punt[i];
		}

		delete[]Punt;

	}

}

void Imagen::CreaImagen(int fil, int col)
{


	ReservaMemoria(fil,col);

}

void Imagen :: PideElementos ()
{
	int i,j;


	for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
		{
			cout << "\nIntroduzca el elemento (" <<i + 1 << ',' << j + 1 << ")\n";
			cin >> Punt[i][j];
		}
	
}

void Imagen :: IntroduceElementos(int valor,int fil,int col)
{

	Punt[fil][col]=valor;

}

void Imagen:: ImagenTranspuesta ()
{
	int i,j;
	Imagen imag_temp(Columnas,Filas);

		for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
			imag_temp.Punt[j] [i] = Punt[i] [j];
	
	*(this) = imag_temp;
}

void Imagen :: Raiz ()
{
	int i,j;

		for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
			Punt[i][j] = int(sqrt (Punt[i] [j]));
	
}


void Imagen :: Cuadrado ()
{
	int i,j;

		for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
			 Punt[i][j] *= Punt[i][j];
	
}

void Imagen :: Anniade (Imagen & imag)
{
	int i,j;

		for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
			Punt[i][j] += imag.Punt[i][j];
	
}

void Imagen::Visualiza()
{
	int i,j;


		for(i=0;i<Filas;i++)
		{

			
			for(j=0;j<Columnas;j++)
			{
				cout<<(int)Punt[i][j]<<'\t';
					
			}
		
			cout<<endl;


		}
			cout<<"Pulsa una tecla para continuar";
			cin.get();
		
}

/************************	             	Operadores	    		************************/

Imagen& Imagen::operator=(const Imagen&imag)

{

	int i,j;
	
	{

		
		LiberaMemoria();

		Filas=imag.Filas;
		Columnas=imag.Columnas;


	

		CreaImagen(Filas,Columnas);

		for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
				Punt[i][j]=imag.Punt[i][j];

			
	}
	return(*this);

	




}

Imagen& Imagen:: operator=(const int valor)
{
		int i,j;



		for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
				Punt[i][j]=valor;

		return*this;
	


}
		

ostream &operator<<(ostream& salida, const Imagen &imag)
{	

	int i,j;

	for(i=0;i<imag.Filas;i++)
	{

		salida<<"\n";

		for(j=0;j<imag.Columnas;j++)

		
			
			salida<<(int)imag.Punt[i][j];
	}
		

	return salida;

}







/******************************** Fichero ********************************/

class Fichero: private fstream,public Imagen

{


	char* NomFich;
	public:
	
		Fichero();
		~Fichero();

		void VolcarFicheroArray();

	
};

Fichero::Fichero():Imagen()
{

	NomFich=(char*)NULL;
	NomFich=new char[25];

	cout<< "Nombre del fichero:";

	cin>>NomFich;

}


Fichero::~Fichero()
{

	if (NomFich!=(char*)NULL)
	
		delete[]NomFich;

}



void Fichero::VolcarFicheroArray()

{

	int f,c,i,j;
	unsigned char elem;



	open(NomFich,ios::nocreate|ios::in|ios::binary);
	if(!fail()&&!bad())
	{

		read((char*)&f,sizeof(int));
		read((char*)&c,sizeof(int));

		CreaImagen(f,c);



	
		

			for(i=0;i<Filas;i++)

				for(j=0;j<Columnas;j++)
			{

					read((char*)&elem,sizeof(unsigned char));
					Punt[i][j]=elem;

			
			}
		

		


	}
	else
		cout<<"\nError al abrir el fichero\n";

}




/******************************	Base ****************************/

class Base:public Imagen

{

public:

	void CompruebaDestino(Imagen&imag);

};



void Base::CompruebaDestino(Imagen&imag)
{
	int fil,col, nfil,ncol;


	nfil=imag.getfilas();
	ncol=imag.getcolumnas();


	fil=getfilas();
	col=getcolumnas();

	if(nfil!=fil)
		fil=nfil;
	if(ncol!=col)
		col=ncol;



	CreaImagen(fil,col);



}


/*******************************	Complementacion,Binarizacion		****************************/

class CompBin: public Base

{



public:

		void Complementa( Imagen& imag);
		void Binariza( Imagen& imag);






};

void CompBin::Complementa(Imagen& imag)
{

	int i,j;

	
CompruebaDestino(imag);

	



			for(i=0;i<Filas;i++)

				for(j=0;j<Columnas;j++)
				{
					Punt[i][j]=(255-imag.getvalor(i,j));
				}

}





void CompBin::Binariza(Imagen&imag)
{

	int i,j;

	CompruebaDestino(imag);



	for(i=0;i<Filas;i++)

				for(j=0;j<Columnas;j++)
				{
					if(imag.getvalor(i,j)<127)
					Punt[i][j]=0;
					else
					Punt[i][j]=1;
				}

}

/*******************************	Media,Convolucion,Sobel	****************************/

class MedConvSob: public Imagen
{	
		
public:

		MedConvSob(const Imagen&obj);
		MedConvSob(const MedConvSob&obj);

		void Media();
		void Convolucion();
		void OperadoresSobel();



		void  AplicaMascara (Imagen&matriz, int orden, int dimension);

	    int MenuSuavizado ();
	 
		void ControlaDesborde ();

		



	
};

MedConvSob::MedConvSob(const Imagen&obj):Imagen()
{
	Imagen::operator =(obj);
}

MedConvSob::MedConvSob(const MedConvSob&obj):Imagen()
{
	Imagen::operator =(obj);
}


/******************************** Media***************************************/



void MedConvSob:: Media ()
{




	int dimension, orden, suma = 0;
	
	cout << ("Introduza el orden de la media 'n' (1, 2...) (tamano = (2n + 1)\n");
	cin >> orden;

	dimension =2*orden + 1;

	Imagen matriz (dimension, dimension);
		
	matriz = 1;
	
	AplicaMascara (matriz, orden, dimension);
}





/******************************** Convolucion**************************************/

void MedConvSob:: Convolucion()
{


	

	int dimension, suma = 0, opcion, orden,media;
	
	cout << ("Introduza el orden de filtro de suavizado 'n' (1, 2...) (tamannio = (2n + 1)\n");
	cin >> orden;
	
	dimension = 2 * orden + 1;

	Imagen matriz(dimension, dimension);
		
	matriz = 1;
	
	opcion = MenuSuavizado ();

	switch (opcion)
	{
	case 1:
		{
			cout << "Introduzca la media\n";
			cin >> media;
			matriz.IntroduceElementos(media,orden,orden);
			break;
		}

	case 2:
		{
			matriz.PideElementos ();
			break;
		}
	}
	
	AplicaMascara (matriz, orden, dimension);

	ControlaDesborde ();

}



/*******************************	Gradiente	****************************/


void MedConvSob:: OperadoresSobel()
{



	
		
	const int dim = 3;
	int orden = (dim - 1) / 2;

	Imagen mask (dim, dim);
	MedConvSob  temp (*this), temp2 (*(this));



	mask.IntroduceElementos(-1,0,0);   mask.IntroduceElementos(0,0,1);  mask.IntroduceElementos(1,0,2);
	mask.IntroduceElementos(-2,1,0);   mask.IntroduceElementos(0,1,1);	mask.IntroduceElementos(2,1,2);
	mask.IntroduceElementos(-1,2,0);   mask.IntroduceElementos(0,2,1);	mask.IntroduceElementos(1,2,2);
	

	temp.AplicaMascara (mask, orden, dim);

	mask.ImagenTranspuesta ();
	

	temp2.AplicaMascara (mask, orden, dim);

	temp.Cuadrado ();
	temp2.Cuadrado ();
	
	temp.Anniade (temp2);
	temp.Raiz ();
	temp.ControlaDesborde ();
	*(this) = temp;

}

/*************************** Funciones de la media,la convolucion y Sobel*****************/

void MedConvSob:: AplicaMascara (Imagen&matriz, int orden, int dimension)
{



	int c_1,c_2,c_3,c_4,c_5,c_6,suma=0;
	Imagen temp(Filas,Columnas);

	temp=*(this);




	for (c_1 = orden; c_1 < Filas- orden; c_1 ++)
	{
		for (c_2 = orden; c_2 < Columnas - orden; c_2 ++)
		{
			for (c_3 = c_1 - orden, c_5 = 0; c_3 <= c_1 + orden; c_3 ++, c_5 ++)
			{
				for (c_4 = c_2 - orden,c_6 = 0; c_4 <= c_2 + orden; c_4 ++, c_6 ++)
					suma +=getvalor(c_3,c_4) * matriz.getvalor(c_5,c_6);
			}
			suma /= (dimension * dimension);
			temp = suma;
			suma = 0;
		}
	}

	*this=temp;


}


int MedConvSob:: MenuSuavizado ()
{
	int opcion;

	do
	{
		cout << "1-Media\n2-Introducir todos los elementos\n";
		cin >> opcion;
		
		cout << '\n';
	}while (opcion < 1 || opcion > 2);
	

	return (opcion);
}

void MedConvSob::  ControlaDesborde ()
{
	int i,j;

	for(i=0;i<Filas;i++)
			for(j=0;j<Columnas;j++)
		{
			if (Punt[i][j] > 255)
				Punt [i][j] = 255;
			else
			{
				if (Punt[i][j] < 0)
					Punt[i][j] = 0;
			}
		}
	
}
/*******************************  Histograma  ****************************************/

class Histograma: public Base
{
public:

	void histograma(Imagen&imag);



};
void Histograma:: histograma(Imagen&imag)
{

	int i,j;
	float *cont;
	unsigned char valor;
	float valor2;
	

	cont = new float[256];

	for (i=0;i<256;i++)
		cont[i] = 0;
	
	for (i=0;i<imag.Filas;i++)
	{
		for (j=0; j<imag.Columnas;j ++)
		{
			valor=imag.getvalor(i,j);
			cont[valor] ++;
		}
			
	}

	for (i=0;i<256;i++)
	{
		if (cont[i]> 0)
		{

			valor2=cont[i];
			cout<< "\nNivel de gris "<< i<< ": " <<(100*valor2 / (Filas*Columnas))<< "%\n";
			
		}
	}


}

/*****************************************************************************************/



int menu(void);


void main(void)
{

	Imagen imag;


	
	int opcion;
	int filas,columnas;
	
	do

		switch(opcion=menu())

		{
				case 1:
					{

					Fichero fich;
					fich.VolcarFicheroArray();
					imag=fich;

					
						break;
					}
				case 2:

					imag.Visualiza();

						break;

				case 3:
					{

				
					CompBin complementa_binariza;
					complementa_binariza.Complementa(imag);
					complementa_binariza.Visualiza();

					break;
					}

				case 4:
					{

					CompBin complementa_binariza;
					complementa_binariza.Binariza(imag);
					complementa_binariza.Visualiza();

					break;
					}

				case 5:
					{

					MedConvSob operaciones(imag);
					operaciones.Media();
					operaciones.Visualiza();
					
					break;
					}

				case 6:
					{

					MedConvSob operaciones(imag);
					operaciones.Convolucion();
					operaciones.Visualiza();
					
					break;
					}

				case 7:

					{

					MedConvSob operaciones(imag);
					operaciones.OperadoresSobel();
					operaciones.Visualiza();

					break;
					}
				case 8:
					{

					Histograma hist;
					hist.histograma(imag);

	

					break;
					}

				case 9:
					{

					cout<<"\nintroduce filas---->";
					cin>>filas;
					cout<<"\nintroduce columnas-->";
					cin>>columnas;

					imag.CreaImagen(filas,columnas);
					imag.PideElementos();



						break;
					}



		}

		while(opcion!=0);

}


int menu(void)

{
	int opcion;

	system("cls");

	cout<<"\n\n1.-CARGAR IMAGEN";
	cout<<"\n2.-VISUALIZAR IMAGEN";
	cout<<"\n3.-COMPLEMENTACION";
	cout<<"\n4.-BINARIZACION";
	cout<<"\n5.-MEDIA";
	cout<<"\n6.-SUAVIZADO";
	cout<<"\n7.-GRADIENTE CON LOS OPERADORES DE SOBEL";
	cout<<"\n8.-CALCULO DEL HISTOGRAMA";	
	cout<<"\n9.-CARGAR IMAGEN DESDE TECLADO";
	cout<<"\n0.-SALIR DEL PROGRAMA";
	


	cout<<"\n\nElige una opcion:";
	cin>>opcion;

	return opcion;
}