Version:0.9
StartHTML:0000000105
EndHTML:0000016398
StartFragment:0000000152
EndFragment:0000016364
/******************************************************/
/*************** Isidro Pastor Jorda ******************/
/******************************************************/
/****************** Telematica ************************/
/******************************************************/
/************* Practica 6 Ejercicio 5 *****************/
/******************************************************/
#include <iostream.h>
#include <stdlib.h>
const int FILAS = 5;
const int COLUMNAS = 5;
typedef int Matriz[FILAS][COLUMNAS];
/* Prototipos de las funciones */
void InicializaMatriz(Matriz M, int reset);
void GrabarMatriz(Matriz M);
void MostrarMatriz(Matriz M);
void LlamadaSuavizado (Matriz M, Matriz Suavizada);
int Suavizado (Matriz M, int i, int j);
int main()
{
Matriz R, G, B, Rs, Gs, Bs;
cout << " Programa para la suavizacion de matrices " << FILAS << " x " << COLUMNAS << endl;
cout << " Introduce la matriz de Rojos R \n";
InicializaMatriz(R, 0); // Inicializamos la matriz toda con ceros
GrabarMatriz(R); // Llamamos a la funcion para grabar los valores de la matriz uno a uno
cout << " Introduce la matriz de verdes G: \n";
InicializaMatriz(G, 0);
GrabarMatriz(G);
cout << " Introduce la matriz de azules B: \n";
InicializaMatriz(B, 0);
GrabarMatriz(B);
/* Estas llamadas a la funcion LlamadaSuavizado nos iran generando
la matriz correspondiente al suavizado de cada una de las matrices
introducidas, al final de este proceso obtendremos las matrices
suavizadas de cada una de las matrices originales */
LlamadaSuavizado (R, Rs);
LlamadaSuavizado (G, Gs);
LlamadaSuavizado (B, Bs);
/* Aqui ya mostramos por pantalla las matrices suavizadas */
cout << endl << " Las matrices suavizadas son las siguientes: \n";
cout << endl << " Matriz de Rojos Suavizada \n";
MostrarMatriz(Rs);
cout << endl << " Matriz de Verdes Suavizada \n";
MostrarMatriz(Gs);
cout << endl << " Matriz de Azules Suavizada \n";
MostrarMatriz(Bs);
system("PAUSE");
return 0;
}
/******************************************************************
* Funcion: InicializaMatriz
* Descripcion: Funcion que inicializa una matriz al valor de reset
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E/S Matriz a inicializar
* reset E Valor usado para inicializar la matriz
*
* Valor devuelto:
* void, la matriz no devuelve nada pero modifica el vector
*******************************************************************/
void InicializaMatriz(Matriz M, int reset)
{
for (int i = 0; i < FILAS; i++ )
for (int j = 0; j< COLUMNAS; j++)
M[i][j] = reset;
return;
}
/******************************************************************
* Funcion: GrabarMatriz
* Descripcion: Funcion para grabar en la matriz los datos introducidos
* por teclado.
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E/S Matriz que iremos asignando valores leidos por teclado
*
*
* Valor devuelto:
* void, no devuelve nada la funcion pero modifica la matriz M
*******************************************************************/
void GrabarMatriz(Matriz M)
{
for (int i = 0; i < FILAS; i++ )
for (int j = 0; j< COLUMNAS; j++)
{
do
{
cout << " Introduce el valor para la entrada "<< i << " " << j << endl;
cin >> M[i][j];
}
while (M[i][j] < 0 || M[i][j] > 255);
system("cls");
MostrarMatriz(M);
}
}
/******************************************************************
* Funcion: MostrarMatriz
* Descripcion: Funcion para mostrar por pantalla la matriz tabulada
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E Matriz a mostrar por pantalla
*
*
* Valor devuelto:
* void, la funcion solo muestra por pantalla la matriz
*******************************************************************/
void MostrarMatriz(Matriz M)
{
cout << endl << endl;
for (int i = 0; i < FILAS; i++ )
{ for (int j = 0; j< COLUMNAS; j++)
{
if (M[i][j] < 10) // Si el numero es menos que 10 introducimos 3 espacios para que quede bien la salida por pantalla
cout << " " << M[i][j];
else
if (M[i][j] < 100) // Si es mas pequeño que 100 introduciremos el numero con solo 2 espacios de separacion
cout << " " << M[i][j];
else
cout << " " << M[i][j]; // Y si fuera mayor que 100 entonces un espacio simple para separar las columnas
}
cout << endl;
}
cout << endl;
}
/*************************************************************************************
* Funcion: LlamadaSuavizado
* Descripcion: Funcion que realizara las llamadas a la funcion de suavizado dato a dato
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E Matriz a mostrar por pantalla
* Suavizada E/S Matriz que contendra la suavización de elementos de M
*
* Valor devuelto:
* void, la funcion hara sucesivas modificaciones en las matrices de entrada
*************************************************************************************/
void LlamadaSuavizado (Matriz M, Matriz Suavizada)
{
for (int i = 0; i < FILAS; i++)
for (int j = 0; j < COLUMNAS; j++)
Suavizada[i][j] = Suavizado (M, i, j); // Para cada i,j llamamos a la funcion Suavizado para generar el valor medio
}
/*********************************************************************************************
* Funcion: Suavizado
* Descripcion: Funcion que hara el suavizado de cada valor de la matriz de entrada
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E Matriz a mostrar por pantalla
* i E Fila del elemento del que queremos hacer la media
* j E Columna del elemento del que queremos hacer la media
*
* Valor devuelto:
* La funcion devuelve el valor del entero resultante de hacer la suma de los vecinos
* del valor M[i][j] de entrada mas el valor de M[i][j] dividido por el numero de vecinos + 1
* Si el punto es de los limites solo se contaran los vecinos existentes para hacer la media.
***************************************************************************************************/
int Suavizado (Matriz M, int i, int j)
{
int contador, aux;
aux = M[i][j]; // Inicializamos el contador con el valor en el punto de entrada
contador = 0; // Contador para los valores sumados, inicializado a cero
if ( j+1 < COLUMNAS) // comprobacion lateral derecha
{
aux = aux + M[i][j+1];
contador++;
}
if ( j-1 >= 0) // comprobacion lateral izquierda
{
aux = aux + M[i][j-1];
contador++;
}
if ( i+1 < FILAS) // comprobacion vertical abajo
{
aux = aux + M[i+1][j];
contador++;
}
if ( i-1 >= 0) // comprobacion vertical arriba
{
aux = aux + M[i-1][j];
contador++;
}
if ( ( i-1 >= 0 )&& ( j+1 < COLUMNAS ) ) // Diagonal Superior derecha
{
aux = aux + M[i-1][j+1];
contador++;
}
if ( ( i-1 >= 0 )&& ( j-1 >= 0 ) ) // Diagonal Superior izquierda
{
aux = aux + M[i-1][j-1];
contador++;
}
if ( ( i+1 < FILAS )&& ( j-1 >= 0 ) ) // Diagonal Inferior izquierda
{
aux = aux + M[i+1][j-1];
contador++;
}
if ( ( i+1 < FILAS )&& ( j+1 < COLUMNAS ) ) // Diagonal Inferior derecha
{
aux = aux + M[i+1][j+1];
contador++;
}
return ( aux / (contador + 1 ) );
}