private void btnRealizarOperacion_Click(object sender, RoutedEventArgs e)
{
señalResultado = null;
switch (cbTipoOperacion.SelectedIndex)
{
case 0: //suma
señalResultado = Señal.sumar(señal, segundaSeñal);
break;
case 1: //multiplicacion
señalResultado = Señal.multiplicar(señal, segundaSeñal);
break;
case 2: //Convolucion
señalResultado = Señal.convolucionar(señal, segundaSeñal);
break;
default:
break;
}
señalResultado.actualizarAmplitudMaxima();
plnGraficaResultado.Points.Clear();
lblAmplitudMaximaY_Resultado.Text = señalResultado.AmplitudMaxima.ToString("F");
lblAmplitudMaximaNegativaY_Resultado.Text = "-" + señalResultado.AmplitudMaxima.ToString("F");
//PRIMERA SEÑAL
if (señalResultado != null)
{
//Recorre todos los elementos de una coleccion o arreglo
foreach (Muestra muestra in señalResultado.Muestras)
{
plnGraficaResultado.Points.Add(new Point((muestra.X - señalResultado.TiempoInicial) *
scrContenedor_Resultado.Width, (muestra.Y / señalResultado.AmplitudMaxima *
((scrContenedor_Resultado.Height / 2.0) - 30) * -1) + (scrContenedor_Resultado.Height / 2)));
}
}
plnEjeXResultado.Points.Clear();
//Punto del principio
plnEjeXResultado.Points.Add(new Point(0, (scrContenedor_Resultado.Height / 2)));
//Punto del final
plnEjeXResultado.Points.Add(new Point((señalResultado.TiempoFinal - señalResultado.TiempoInicial) *
scrContenedor_Resultado.Width, (scrContenedor_Resultado.Height / 2)));
plnEjeYResultado.Points.Clear();
//Punto del principio
plnEjeYResultado.Points.Add(new Point((0 - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width,
(señalResultado.AmplitudMaxima * ((scrContenedor_Resultado.Height / 2.0) - 30) * -1) +
(scrContenedor_Resultado.Height / 2)));
//Punto del final
plnEjeYResultado.Points.Add(new Point((0 - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width,
(-señalResultado.AmplitudMaxima * ((scrContenedor_Resultado.Height / 2.0) - 30) * -1) +
(scrContenedor_Resultado.Height / 2)));
}
private void btnTransformadaFourier_Click(object sender, RoutedEventArgs e)
{
Señal transformada = Señal.transformar(señal);
transformada.actualizarAmplitudMaxima();
plnGraficaResultado.Points.Clear();
lblAmplitudMaximaY_Resultado.Text = transformada.AmplitudMaxima.ToString("F");
lblAmplitudMaximaNegativaY_Resultado.Text = "-" + transformada.AmplitudMaxima.ToString("F");
//PRIMERA SEÑAL
if (transformada != null)
{
//Recorre todos los elementos de una coleccion o arreglo
foreach (Muestra muestra in transformada.Muestras)
{
plnGraficaResultado.Points.Add(new Point((muestra.X - transformada.TiempoInicial) * scrContenedor_Resultado.Width, (muestra.Y /
transformada.AmplitudMaxima * ((scrContenedor_Resultado.Height / 2.0) - 30) * -1) +
(scrContenedor_Resultado.Height / 2)));
}
double valorMaximo = 0;
int indiceMaximo = 0;
int indiceActual = 0;
foreach (Muestra muestra in transformada.Muestras)
{
if (muestra.Y > valorMaximo)
{
valorMaximo = muestra.Y;
indiceMaximo = indiceActual;
}
indiceActual++;
if (indiceActual > (double)transformada.Muestras.Count / 2.0)
{
break;
}
}
double frecuenciaFundamental = (double)indiceMaximo * señal.FrecuenciaMuestreo / (double)transformada.Muestras.Count;
Hertz.Text = frecuenciaFundamental.ToString() + "Hz";
}
plnEjeXResultado.Points.Clear();
//Punto del principio
plnEjeXResultado.Points.Add(new Point(0, (scrContenedor_Resultado.Height / 2)));
//Punto del final
plnEjeXResultado.Points.Add(new Point((transformada.TiempoFinal - transformada.TiempoInicial) * scrContenedor_Resultado.Width,
(scrContenedor_Resultado.Height / 2)));
plnEjeYResultado.Points.Clear();
//Punto del principio
plnEjeYResultado.Points.Add(new Point((0 - transformada.TiempoInicial) * scrContenedor_Resultado.Width, (transformada.AmplitudMaxima *
((scrContenedor_Resultado.Height / 2.0) - 30) * -1) + (scrContenedor_Resultado.Height / 2)));
//Punto del final
plnEjeYResultado.Points.Add(new Point((0 - transformada.TiempoInicial) * scrContenedor_Resultado.Width, (-transformada.AmplitudMaxima *
((scrContenedor_Resultado.Height / 2.0) - 30) * -1) + (scrContenedor_Resultado.Height / 2)));
}
private void btnRealizarOperacion_Click(object sender, RoutedEventArgs e)
{
señalResultado = null;
switch (cbTipoOperacion.SelectedIndex)
{
case 0: //Suma
//los metodos estaticos no necesitan una instancia
señalResultado = Señal.sumar(señal, segundaSeñal);
break;
case 1: //multiplicacion
señalResultado = Señal.multiplicar(señal, segundaSeñal);
break;
case 2: //convolucion
señalResultado = Señal.convolucionar(señal, segundaSeñal);
break;
default:
break;
}
//se actualiza la amplitud maxima del resultado
señalResultado.actualizarAmplitudMaxima();
plnGraficaResultado.Points.Clear();
//cambia los valores de la etiqueta
//La F es que da el formato para redondear a 2 decimales, la funcion ToString puede recibir un parametro que es el que va a decidir en que formato va a estar,existen varios parametros
lblAmplitudMaximaPositivaY_Resultado.Text = señalResultado.AmplitudMaxima.ToString("F");
lblAmplitudMaximaNegativaY_Resultado.Text = "-" + señalResultado.AmplitudMaxima.ToString("F");
//hacerlo si la señal no es nula
if (señalResultado != null)
{
//recorrer una coleccion o arreglo
//muestra toma el valor de señal.muestra en cada recorrido del ciclo
foreach (Muestra muestra in señalResultado.Muestras)
{
//se evalua la señal, luego se ajusta y de ahi se agrega el punto
plnGraficaResultado.Points.Add(new Point((muestra.X - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, (muestra.Y / señalResultado.AmplitudMaxima * ((scrContenedor_Resultado.Height / 2) - 30) * -1) + (scrContenedor_Resultado.Height / 2)));
}
}
//Graficando el eje de X
plnEjeXResultado.Points.Clear();
//Punto de inicio.
plnEjeXResultado.Points.Add(new Point(0, (scrContenedor_Resultado.Height / 2)));
//Punto de fin.
plnEjeXResultado.Points.Add(new Point((señalResultado.TiempoFinal - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, (scrContenedor_Resultado.Height / 2)));
//Graficando el eje de Y
plnEjeYResultado.Points.Clear();
//Punto de inicio.
plnEjeYResultado.Points.Add(new Point((0 - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, (((scrContenedor_Resultado.Height / 2.0) - 30) * -1) + (scrContenedor_Resultado.Height / 2)));
//Punto de fin.
plnEjeYResultado.Points.Add(new Point((0 - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, (-1 * ((scrContenedor_Resultado.Height / 2.0) - 30) * -1) + (scrContenedor_Resultado.Height / 2)));
}
public static Señal convolucionar
(Señal operando1, Señal operando2)
{
SeñalPersonalizada resultado =
new SeñalPersonalizada();
resultado.TiempoInicial =
operando1.TiempoInicial +
operando2.TiempoInicial;
resultado.TiempoFinal =
operando1.TiempoFinal +
operando2.TiempoFinal;
resultado.FrecuenciaMuestreo =
operando1.FrecuenciaMuestreo;
double periodoMuestreo =
1 / resultado.FrecuenciaMuestreo;
double duracionSeñal =
resultado.TiempoFinal - resultado.TiempoInicial;
double cantindadMuestrasResultado =
duracionSeñal * resultado.FrecuenciaMuestreo;
double instanteActual =
resultado.TiempoInicial;
for (int n = 0;
n < cantindadMuestrasResultado;
n++)
{
double valorMuestra = 0;
for (int k = 0;
k < operando2.Muestras.Count;
k++)
{
if ((n - k) >= 0 &&
(n - k) < operando2.Muestras.Count)
{
valorMuestra +=
operando1.Muestras[k].Y
* operando2.Muestras[n - k].Y;
}
}
valorMuestra /= resultado.FrecuenciaMuestreo;
Muestra muestra =
new Muestra(instanteActual, valorMuestra);
resultado.Muestras.Add(muestra);
instanteActual +=
periodoMuestreo;
}
return(resultado);
}
private void BotonOperacion_Click(object sender, RoutedEventArgs e)
{
señalResultado = null;
switch (cb_TipoOperacion.SelectedIndex)
{
// Suma
case 0:
señalResultado = Señal.suma(señal, señal_2);
break;
// Multiplicación
case 1:
señalResultado = Señal.multiplicacion(señal, señal_2);
break;
// Convolución
case 2:
señalResultado = Señal.convolucion(señal, señal_2);
break;
// Correlación
case 3:
señalResultado = Señal.correlacion(señal, señal_2);
break;
default:
break;
}
// Actualizar
señalResultado.actualizarAmplitudMaxima();
// Limpieza de polylines
plnGrafica_Resultado.Points.Clear();
// Impresión de la amplitud máxima en los labels de la ventana.
lbl_AmplitudMaxima_Resultado.Text = señalResultado.AmplitudMaxima.ToString("F");
lbl_AmplitudMinima_Resultado.Text = "-" + señalResultado.AmplitudMaxima.ToString("F");
if (señalResultado != null)
{
foreach (Muestra muestra in señalResultado.Muestras)
{
plnGrafica_Resultado.Points.Add(new Point((muestra.X - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, (muestra.Y / señalResultado.AmplitudMaxima * ((scrContenedor_Resultado.Height / 2) - 30) * -1 + (scrContenedor_Resultado.Height / 2))));
}
}
// Línea del Eje X
plnEjeX_Resultado.Points.Clear();
plnEjeX_Resultado.Points.Add(new Point(0, scrContenedor_Resultado.Height / 2));
plnEjeX_Resultado.Points.Add(new Point((señalResultado.TiempoFinal - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, scrContenedor_Resultado.Height / 2));
// Línea del Eje Y
plnEjeY_Resultado.Points.Clear();
plnEjeY_Resultado.Points.Add(new Point((-señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, 0));
plnEjeY_Resultado.Points.Add(new Point((-señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, scrContenedor_Resultado.Height));
}
private void btnRealizarOperacion_Click(object sender, RoutedEventArgs e)
{
señalResultado = null;
switch (cbOperacion.SelectedIndex)
{
case 0: //suma
señalResultado = Señal.sumar(señal, segundaSeñal);
break;
case 1: //Multiplicacion
señalResultado = Señal.multiplicar(señal, segundaSeñal);
break;
case 2: //Convolucion
señalResultado = Señal.convolucionar(señal, segundaSeñal);
break;
case 3: //Correlación
señalResultado = Señal.correlacion(señal, segundaSeñal);
break;
default:
break;
}
plnResultado.Points.Clear();
//actualizar amplitud maxima
señalResultado.actualizarAmplitudMaxima();
if (señalResultado != null)
{
//recorrer una coleccion o arreglo
foreach (Muestra muestra in señalResultado.muestras)
{
plnResultado.Points.Add(new Point((muestra.x - señalResultado.tiempoInicial) * scrContenedorResultado.Width, (muestra.y / señalResultado.amplitudMaxima * ((scrContenedorResultado.Height / 2.0) - 30) * -1) + (scrContenedorResultado.Height / 2)));
}
}
lblAmplitudMaximaY_Resultado.Text = señalResultado.amplitudMaxima.ToString();
lblAmplitudMaximaNegativaY_Resultado.Text = "-" + señalResultado.amplitudMaxima.ToString();
plnEjeXResultado.Points.Clear();
//punto del principio
plnEjeXResultado.Points.Add(new Point(0, scrContenedor.Height / 2));
//punto del fin
plnEjeXResultado.Points.Add(new Point((señalResultado.tiempoFinal - señalResultado.tiempoInicial) * scrContenedorResultado.Width, scrContenedorResultado.Height / 2));
plnEjeYResultado.Points.Clear();
//punto del principio
plnEjeYResultado.Points.Add(new Point((0 - señalResultado.tiempoInicial) * scrContenedorResultado.Width, (1 * ((scrContenedorResultado.Height / 2.0) - 30) * -1) + (scrContenedorResultado.Height / 2)));
//punto del fin
plnEjeYResultado.Points.Add(new Point((0 - señalResultado.tiempoInicial) * scrContenedorResultado.Width, (-1 * ((scrContenedorResultado.Height / 2.0) - 30) * -1) + (scrContenedorResultado.Height / 2)));
}
private void btnRealizarOperacion_Click(object sender, RoutedEventArgs e)
{
señalResultado = null;
switch (cbTipoOperaacion.SelectedIndex)
{
case 0: //Suma
señalResultado =
Señal.sumar(señal, segundaSeñal);
break;
case 1: //Multiplicacion
señalResultado = Señal.multiplicar(señal, segundaSeñal);
break;
case 2:
señalResultado = Señal.convolucionar(señal, segundaSeñal);
break;
default:
break;
}
señalResultado.actualizarAmplitudMaxima();
plnGraficaResultado.Points.Clear();
lblAmplitudMaximaY_Resultado.Text = señalResultado.AmplitudMaxima.ToString("F");
lblAmplitudMazimaNegativaY_Resultado.Text = "-" + señalResultado.AmplitudMaxima.ToString("F");
if (señalResultado != null)
{
foreach (Muestra muestra in señalResultado.Muestras)
{
plnGraficaResultado.Points.Add(new Point((muestra.X - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width,
(muestra.Y / señalResultado.AmplitudMaxima) * (((scrContenedor_Resultado.Height / 2.0) - 30) * -1) + (scrContenedor_Resultado.Height / 2))
);
}
}
//EJE X
plnEjexResultado.Points.Clear();
//Punto de Principio
plnEjexResultado.Points.Add(new Point(0, (scrContenedor_Resultado.Height / 2)));
//Punto del fin
plnEjexResultado.Points.Add(new Point((señalResultado.TiempoFinal - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, (scrContenedor_Resultado.Height / 2)));
//
//EJE Y
plnEjeyResultado.Points.Clear();
//Punto de Principio
plnEjeyResultado.Points.Add(new Point((0 - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, señalResultado.AmplitudMaxima * (((scrContenedor_Resultado.Height / 2.0) - 30) * -1) + (scrContenedor_Resultado.Height / 2)));
//Punto del fin
plnEjeyResultado.Points.Add(new Point((0 - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, -señalResultado.AmplitudMaxima * (((scrContenedor_Resultado.Height / 2.0) - 30) * -1) + (scrContenedor_Resultado.Height / 2)));
//
}
private void BotonTransformadadeFourier_Click(object sender, RoutedEventArgs e)
{
Señal transformada = Señal.transformar(señal);
transformada.actualizarAmplitudMaxima();
// Limpieza de polylines
plnGrafica_Resultado.Points.Clear();
// Impresión de la amplitud máxima en los labels de la ventana.
lbl_AmplitudMaxima_Resultado.Text = transformada.AmplitudMaxima.ToString("F");
lbl_AmplitudMinima_Resultado.Text = "-" + transformada.AmplitudMaxima.ToString("F");
if (transformada != null)
{
// Sirve para recorrer una coleccion o arreglo
foreach (Muestra muestra in transformada.Muestras)
{
plnGrafica_Resultado.Points.Add(new Point((muestra.X - transformada.TiempoInicial) * scrContenedor_Resultado.Width, (muestra.Y / transformada.AmplitudMaxima * ((scrContenedor_Resultado.Height / 2) - 30) * -1 + (scrContenedor_Resultado.Height / 2))));
}
}
double valorMaximo = 0;
int indiceMaximo = 0;
int indiceActual = 0;
foreach (Muestra muestra in transformada.Muestras)
{
if (muestra.Y > valorMaximo)
{
valorMaximo = muestra.Y;
indiceMaximo = indiceActual;
}
indiceActual++;
if (indiceActual > ((double)transformada.Muestras.Count / 2))
{
break;
}
}
double frecuenciaFundamental = ((double)indiceMaximo * señal.FrecuenciaMuestreo) / (double)transformada.Muestras.Count;
lbl_Hz.Text = frecuenciaFundamental.ToString("F") + " HZ";
// Línea del Eje X
plnEjeX_Resultado.Points.Clear();
plnEjeX_Resultado.Points.Add(new Point(0, scrContenedor_Resultado.Height / 2));
plnEjeX_Resultado.Points.Add(new Point((transformada.TiempoFinal - transformada.TiempoInicial) * scrContenedor_Resultado.Width, scrContenedor_Resultado.Height / 2));
// Línea del Eje Y
plnEjeY_Resultado.Points.Clear();
plnEjeY_Resultado.Points.Add(new Point((-transformada.TiempoInicial) * scrContenedor_Resultado.Width, 0));
plnEjeY_Resultado.Points.Add(new Point((-transformada.TiempoInicial) * scrContenedor_Resultado.Width, scrContenedor_Resultado.Height));
}
public static Señal limiteSuperior(Señal señal1, Señal señal2)
{
SeñalResultante resultado = new SeñalResultante();
resultado.TiempoInicial = señal1.TiempoFinal;
resultado.TiempoFinal = señal1.TiempoFinal;
resultado.FrecuenciaMuestreo = señal1.FrecuenciaMuestreo;
int indice = 0;
foreach (var muestra in señal1.Muestras)
{
double nuevoValor = 0;
if (muestra.Y >= señal2.Muestras[indice].Y)
{
nuevoValor = muestra.Y;
}
else if (muestra.Y < señal2.Muestras[indice].Y)
{
nuevoValor = señal2.Muestras[indice].Y;
}
resultado.Muestras.Add(new Muestra(muestra.X, nuevoValor));
/*if (Math.Abs(nuevoValor) > resultado.AmplitudMaxima)
* {
* resultado.AmplitudMaxima = Math.Abs(nuevoValor);
* }*/
//double efedeequis = muestra.Y * señal1.Muestras[indice].Y;
//double gedeequis = muestra.Y * señal2.Muestras[indice].Y;
//resultado.Muestras.Add(new Muestra(muestra.X, efedeequis));
/*resultado.Muestras.Add(new Muestra(muestra.X, gedeequis));
*
* if (efedeequis >= gedeequis)
* {
* resultado.AmplitudMaxima = efedeequis;
* }
*
* if (efedeequis < gedeequis)
* {
* resultado.AmplitudMaxima = gedeequis;
* }*/
indice++;
}
return(resultado);
}
public static Señal desplazamientoAmplitud(Señal señalOriginal, double factorDesplazamiento)
{
SeñalResultante resultado = new SeñalResultante();
resultado.TiempoInicial = señalOriginal.TiempoInicial;
resultado.TiempoFinal = señalOriginal.TiempoFinal;
resultado.FrecuenciaMuestreo = señalOriginal.FrecuenciaMuestreo;
foreach (var muestra in señalOriginal.Muestras)
{
resultado.Muestras.Add(new Muestra(muestra.X, muestra.Y + factorDesplazamiento));
}
return(resultado);
}
public static Señal limiteInferior(
Señal señal1, Señal señal2)
{
SeñalResultante resultado =
new SeñalResultante();
resultado.TiempoInicial =
señal1.TiempoInicial;
resultado.TiempoFinal =
señal1.TiempoFinal;
resultado.FrecuenciaMuestreo =
señal1.FrecuenciaMuestreo;
int indice = 0;
foreach (var muestra in señal1.Muestras)
{
double valor1 = muestra.Y;
double valor2 = señal2.Muestras[indice].Y;
double nuevoValor =
(muestra.Y +
señal2.Muestras[indice].Y) / 2.0;
if (valor1 < valor2)
{
nuevoValor = valor1;
}
else
{
nuevoValor = valor2;
}
resultado.Muestras.Add(
new Muestra(muestra.X, nuevoValor));
if (Math.Abs(nuevoValor) >
resultado.AmplitudMaxima)
{
resultado.AmplitudMaxima =
Math.Abs(nuevoValor);
}
indice++;
}
return(resultado);
}
private void btnRealizarOperacion_Click(object sender, RoutedEventArgs e)
{
señalResultado = null;
switch (cbTipoOperacion.SelectedIndex)
{
case 0: //suma
señalResultado = Señal.sumar(señal, segundaSeñal);
break;
case 1: //multiplicacion
break;
default:
break;
}
// Actualizar
señalResultado.actualizarAmplitudMaxima();
plnGraficaResultado.Points.Clear();
lbl_AmplitudMaxima_Resultado.Text = amplitudMaxima.ToString("F");
lbl_AmplitudMinima_Resultado.Text = "-" + señalResultado.AmplitudMaxima.ToString("F");
if (señalResultado != null)
{
// Sirve para recorrer una coleccion o arreglo
foreach (Muestra muestra in señalResultado.Muestras)
{
plnGraficaResultado.Points.Add(new Point((muestra.X - señalResultado.TiempoInicial) *
scrContenedor_Resultado.Width, (muestra.Y / señalResultado.AmplitudMaxima *
((scrContenedor_Resultado.Height / 2) - 30) * -1 + (scrContenedor_Resultado.Height / 2))));
}
}
// Línea del Eje X
plnEjeXResultado.Points.Clear();
plnEjeXResultado.Points.Add(new Point(0, scrContenedor.Height / 2));
plnEjeXResultado.Points.Add(new Point((señalResultado.TiempoFinal - señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, scrContenedor_Resultado.Height / 2));
// Línea del Eje Y
plnEjeYResultado.Points.Clear();
plnEjeYResultado.Points.Add(new Point((-señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, 0));
plnEjeYResultado.Points.Add(new Point((-señalResultado.TiempoInicial) * scrContenedor_Resultado.Width, scrContenedor_Resultado.Height));
}
public static Señal desplazamientoAmplitud(Señal señalOriginal, double cantidadDesplazamiento)
{
SeñalResultante resultado = new SeñalResultante();
resultado.TiempoInicial = señalOriginal.TiempoInicial;
resultado.TiempoFinal = señalOriginal.TiempoFinal;
resultado.FrecuenciaMuestreo = señalOriginal.FrecuenciaMuestreo;
foreach (var muestra in señalOriginal.Muestras)
{
double nuevoValor = muestra.Y + cantidadDesplazamiento;
resultado.Muestras.Add(new Muestra(muestra.X, nuevoValor));
if (Math.Abs(nuevoValor) > resultado.AmplitudMaxima)
{
resultado.AmplitudMaxima = Math.Abs(nuevoValor);
}
}
return(resultado);
}
public static Señal escalarAmplitud(Señal señalOriginal, double factorEscala)
{
SeñalResultante resultado = new SeñalResultante();
resultado.TiempoInicial = señalOriginal.TiempoInicial;
resultado.TiempoFinal = señalOriginal.TiempoFinal;
resultado.FrecuenciaMuestreo = señalOriginal.FrecuenciaMuestreo;
foreach (var muestra in señalOriginal.Muestras)
{
double nuevoValor = muestra.Y * factorEscala;
resultado.Muestras.Add(new Muestra(muestra.X, nuevoValor));
if (Math.Abs((nuevoValor)) > resultado.AmplitudMaxima)
{
resultado.AmplitudMaxima = Math.Abs(nuevoValor);
}
}
return(resultado);
}
public static Señal sumar(Señal sumado1, Señal sumado2)
{
SeñalPersonalizada resultado = new SeñalPersonalizada();
resultado.TiempoInicial = sumado1.TiempoInicial;
resultado.TiempoFinal = sumado1.TiempoFinal;
resultado.FrecuenciaMuestreo = sumado1.FrecuenciaMuestreo;
int indice = 0;
foreach (Muestra muestra in sumado1.Muestras)
{
Muestra muestraResultado = new Muestra();
muestraResultado.X = muestra.X;
muestraResultado.Y = muestra.Y + sumado2.Muestras[indice].Y;
indice++;
resultado.Muestras.Add(muestraResultado);
}
return(resultado);
}
public static Señal transformar(Señal señal)
{
SeñalPersonalizada transformada = new SeñalPersonalizada();
transformada.TiempoInicial = señal.TiempoInicial;
transformada.TiempoFinal = señal.TiempoFinal;
transformada.FrecuenciaMuestreo = señal.FrecuenciaMuestreo;
for (int k = 0; k < señal.Muestras.Count; k++)
{
Complex muestra = 0; //convierte a numero complejo
for (int n = 0; n < señal.Muestras.Count; n++)
{
muestra += señal.Muestras[n].Y * Complex.Exp(-2 * Math.PI * Complex.ImaginaryOne * k * n / señal.Muestras.Count);
}
transformada.Muestras.Add(new Muestra((double)k / (double)señal.Muestras.Count, muestra.Magnitude));
}
return(transformada);
}
public static Señal escalaExponencial(Señal señalOriginal, double exponente)
{
SeñalResultante resultado = new SeñalResultante();
resultado.TiempoInicial = señalOriginal.TiempoInicial;
resultado.TiempoFinal = señalOriginal.TiempoFinal;
resultado.FrecuenciaMuestreo = señalOriginal.FrecuenciaMuestreo;
foreach (var muestra in señalOriginal.Muestras)
{
//Elevar un número con un exponente
double nuevoValor = Math.Pow(muestra.Y, exponente);
resultado.Muestras.Add(new Muestra(muestra.Y, nuevoValor));
if (Math.Abs(nuevoValor) > resultado.AmplitudMaxima)
{
resultado.AmplitudMaxima = Math.Abs(nuevoValor);
}
}
return(resultado);
}
public static Señal desplazarAmplitud(Señal señalOriginal, double factorDesplaze)
{
SeñalResultante resultado = new SeñalResultante();
resultado.TiempoInicial = señalOriginal.TiempoInicial;
resultado.TiempoFinal = señalOriginal.TiempoFinal;
resultado.FrecuenciaMuestreo = señalOriginal.FrecuenciaMuestreo;
foreach (var muestra in señalOriginal.Muestras)
{
double NuevoValor = muestra.Y + factorDesplaze;
resultado.Muestras.Add(new Muestra(muestra.X, NuevoValor));
if (Math.Abs((NuevoValor)) > resultado.AmplitudMaxima)
{
resultado.AmplitudMaxima = Math.Abs(NuevoValor);
}
;
}
return(resultado);
}
public static Señal convolucionar(Señal operando1, Señal operando2)
{
SeñalPersonalizada resultado = new SeñalPersonalizada();
//asi se deteminan los limites de una convolucion, es la suma de los limites interiores y la suma de los limites superiores
resultado.TiempoInicial = operando1.TiempoInicial + operando2.TiempoInicial;
resultado.TiempoFinal = operando1.TiempoFinal + operando2.TiempoFinal;
resultado.FrecuenciaMuestreo = operando1.FrecuenciaMuestreo;
double periodoMuestreo = 1 / resultado.FrecuenciaMuestreo;
double duracionSeñal = resultado.TiempoFinal - resultado.TiempoInicial;
double cantidadMuestrasResultado = duracionSeñal * resultado.FrecuenciaMuestreo;
double instanteActual = resultado.TiempoInicial;
for (int n = 0; n < cantidadMuestrasResultado; n++)
{
double valorMuestraY = 0;
for (int k = 0; k < operando2.Muestras.Count; k++)
{
// el .count es una propiedad que permite contar el numero de valores que tiene una lista
if ((n - k) >= 0 && (n - k) < operando2.Muestras.Count)
{
valorMuestraY += operando1.Muestras[k].Y * operando2.Muestras[n - k].Y;
}
}
valorMuestraY /= resultado.FrecuenciaMuestreo;
Muestra muestra = new Muestra(instanteActual, valorMuestraY);
resultado.Muestras.Add(muestra);
instanteActual += periodoMuestreo;
}
return(resultado);
}
public static Señal sumar(Señal sumando1, Señal sumando2)
{
SeñalPersonalizada resultado = new SeñalPersonalizada();
resultado.tiempoInicial = sumando1.tiempoInicial;
resultado.tiempoFinal = sumando1.tiempoFinal;
resultado.frecuenciaMuestreo = sumando1.frecuenciaMuestreo;
int indice = 0;
foreach (Muestra muestra in sumando1.muestras)
{
Muestra muestraResultado = new Muestra();
muestraResultado.x = muestra.x;
muestraResultado.y = muestra.y + sumando2.muestras[indice++].y;
resultado.muestras.Add(muestraResultado);
}
return(resultado);
}
public static Señal multiplicarseñales(Señal señal1, Señal señal2)
{
SeñalResultante resultado = new SeñalResultante();
resultado.TiempoInicial = señal1.TiempoInicial;
resultado.TiempoFinal = señal1.TiempoFinal;
resultado.FrecuenciaMuestreo = señal1.FrecuenciaMuestreo;
int indice = 0;
foreach (var muestra in señal1.Muestras)
{
double nuevoValor = muestra.Y * señal2.Muestras[indice].Y;
resultado.Muestras.Add(new Muestra(muestra.X, nuevoValor));
if (Math.Abs(nuevoValor) > resultado.AmplitudMaxima)
{
resultado.AmplitudMaxima = Math.Abs(nuevoValor);
}
indice++;
}
return(resultado);
}
public static Señal multiplicar(Señal factor1, Señal factor2)
{
SeñalPersonalizada resultado = new SeñalPersonalizada();
resultado.TiempoInicial = factor1.TiempoInicial;
resultado.TiempoFinal = factor1.TiempoFinal;
resultado.FrecuenciaMuestreo = factor1.FrecuenciaMuestreo;
int indice = 0;
foreach (Muestra muestra in factor1.Muestras)
{
Muestra muestraResultado = new Muestra();
muestraResultado.X = muestra.X;
muestraResultado.Y = muestra.Y * factor2.Muestras[indice].Y;
indice++;
resultado.Muestras.Add(muestraResultado);
}
return(resultado);
}
public static Señal transformar(Señal señal)
{
SeñalPersonalizada transformada = new SeñalPersonalizada();
transformada.TiempoInicial = señal.TiempoInicial;
transformada.TiempoFinal = señal.TiempoFinal;
transformada.FrecuenciaMuestreo = señal.FrecuenciaMuestreo;
for (int k = 0; k < señal.Muestras.Count; k++)
{
Complex muestra = 0;
for (int n = 0; n < señal.Muestras.Count; n++)
{
// Fórmula de la transformada de Fourier
muestra += señal.Muestras[n].Y * Complex.Exp((-2 * Math.PI * Complex.ImaginaryOne * k * n) / señal.Muestras.Count);
}
// Magnitude permite acceder a un número imaginario como número real.
transformada.Muestras.Add(new Muestra((double)k / (double)señal.Muestras.Count, muestra.Magnitude));
}
return(transformada);
}
public static Señal transformadaFourier(Señal señal)
{
SeñalResultante resultado = new SeñalResultante();
resultado.TiempoInicial = señal.TiempoInicial;
resultado.TiempoFinal = señal.TiempoFinal;
resultado.FrecuenciaMuestreo = señal.FrecuenciaMuestreo;
for (int k = 0; k < señal.Muestras.Count; k++)
{
Complex muestra = 0; // = 0 + 0i
for (int n = 0; n < señal.Muestras.Count; n++)
{
muestra += señal.Muestras[n].Y * Complex.Exp(-2 * Math.PI * Complex.ImaginaryOne * k * n / señal.Muestras.Count);
}
resultado.Muestras.Add(new Muestra(señal.Muestras[k].X, muestra.Magnitude));
if (Math.Abs(muestra.Magnitude) > señal.AmplitudMaxima)
{
señal.AmplitudMaxima = Math.Abs(muestra.Magnitude);
}
}
return(resultado);
}
public static Señal multiplicacion(Señal multiplicando1, Señal multiplicando2)
{
SeñalPersonalizada resultado = new SeñalPersonalizada();
// Multiplicandos de la Señal 1
resultado.TiempoInicial = multiplicando1.TiempoInicial;
resultado.TiempoFinal = multiplicando1.TiempoFinal;
resultado.FrecuenciaMuestreo = multiplicando1.FrecuenciaMuestreo;
int indice = 0;
foreach (Muestra muestra in multiplicando1.Muestras)
{
Muestra muestraResultado = new Muestra();
muestraResultado.X = muestra.X;
muestraResultado.Y = muestra.Y * multiplicando2.Muestras[indice].Y;
indice++;
resultado.Muestras.Add(muestraResultado);
}
return(resultado);
}
public static Señal transformar(Señal señal)
{
SeñalPersonalizada transformada = new SeñalPersonalizada();
transformada.TiempoInicial = señal.TiempoInicial;
transformada.TiempoFinal = señal.TiempoFinal;
transformada.FrecuenciaMuestreo = señal.FrecuenciaMuestreo;
for (int k = 0; k < señal.Muestras.Count; k++)
{
// si se pone solo la parte real la parte imaginaria se toma como 0
Complex muestra = 0;
//sumatoria
//imaginaryOne le pone 0 a la parte real y 1 a la parte imaginaria
for (int n = 0; n < señal.Muestras.Count; n++)
{
muestra += señal.Muestras[n].Y * Complex.Exp(-2 * Math.PI * Complex.ImaginaryOne * k * n / señal.Muestras.Count);
}
// para obtener los numeros reales de un numero complejo se utiliza Magnitude
transformada.Muestras.Add(new Muestra((double)k / (double)señal.Muestras.Count, muestra.Magnitude));
}
return(transformada);
}
private void btnGraficar_Click(object sender, RoutedEventArgs e)
{
double tiempoInicial =
double.Parse(txtTiempoInicial.Text);
double tiempoFinal =
double.Parse(txtTiempoFinal.Text);
double frecuenciaMuestreo =
double.Parse(txtFrecuenciaMuestreo.Text);
switch (cbTipoSeñal.SelectedIndex)
{
//Senoidal
case 0:
double amplitud =
double.Parse(
((ConfiguracionSeñalSenoidal)panelConfiguracion.Children[0]).txtAmplitud.Text);
double fase =
double.Parse(
((ConfiguracionSeñalSenoidal)panelConfiguracion.Children[0]).txtFase.Text);
double frecuencia =
double.Parse(
((ConfiguracionSeñalSenoidal)panelConfiguracion.Children[0]).txtFrecuencia.Text);
señal =
new SeñalSenoidal(amplitud, fase, frecuencia);
break;
//Rampa
case 1:
señal = new SeñalRampa();
break;
case 2:
double alpha =
double.Parse(
((ConfiguracionSeñalExponencial)panelConfiguracion.Children[0]).txtAlpha.Text);
señal =
new SeñalExponencial(alpha);
break;
case 3:
señal = new SeñalRectangular();
break;
default:
señal = null;
break;
}
señal.TiempoInicial = tiempoInicial;
señal.TiempoFinal = tiempoFinal;
señal.FrecuenciaMuestreo = frecuenciaMuestreo;
señal.construirSeñalDigital();
if ((bool)cbEscalar.IsChecked)
{
señal.escalar(float.Parse(txtFactorEscala.Text));
}
if ((bool)cbDesplazar.IsChecked)
{
señal.desplazar(float.Parse(txtMagnitudDesplazamiento.Text));
}
if ((bool)cbTruncar.IsChecked)
{
señal.truncar(float.Parse(txtUmbral.Text));
}
señal.actualizarAmplitudMaxima();
amplitudMaxima = señal.AmplitudMaxima;
plnGrafica.Points.Clear();
lblAmplitudMaximaY.Text =
amplitudMaxima.ToString("F");
lblAmplitudMaximaNegativaY.Text =
"-" + amplitudMaxima.ToString("F");
if (señal != null)
{
//Recorrer una coleccion o arreglo
foreach (Muestra muestra in señal.Muestras)
{
plnGrafica.Points.Add(
new Point((muestra.X - tiempoInicial) * scrContenedor.Width
, (muestra.Y / amplitudMaxima * ((scrContenedor.Height / 2.0) - 30) * -1)
+ (scrContenedor.Height / 2))
);
}
}
plnEjeX.Points.Clear();
//Punto del principio
plnEjeX.Points.Add(
new Point(0, //Coordenada X punto inicial
(scrContenedor.Height / 2))); //Coordenada Y punto inicial
//Punto del fin
plnEjeX.Points.Add(
new Point((tiempoFinal - tiempoInicial) * scrContenedor.Width,
// x final
(scrContenedor.Height / 2))); // y final
plnEjeY.Points.Clear();
//Punto del principio
plnEjeY.Points.Add(
new Point((0 - tiempoInicial) * scrContenedor.Width, //Coordenada X punto inicial
( //Coordenada Y punto inicial
((scrContenedor.Height / 2.0) - 30) * -1)
+ (scrContenedor.Height / 2)));
//Punto del fin
plnEjeY.Points.Add(
new Point((0 - tiempoInicial) * scrContenedor.Width, //x final
(-1 * ((scrContenedor.Height / 2.0) - 30) * -1) //y final
+ (scrContenedor.Height / 2)));
}
private void BtnGraficar_Click(object sender, RoutedEventArgs e)
{
double tiempoInicial =
double.Parse(txtTiempoInicial.Text);
double tiempoFinal =
double.Parse(txtTiempoFinal.Text);
double frecuenciaMuestreo =
double.Parse(txtFrecuenciaMuestreo.Text);
Señal señal;
Señal segundaSeñal = null;
Señal señalResultante;
switch (cbTipoSeñal.SelectedIndex)
{
case 0: // Parabolica
señal = new SeñalParabolica();
break;
case 1: //Senoidal
double amplitud =
double.Parse(
((ConfiguracionSeñalSenoidal)
(panelConfiguracion.Children[0])).txtAmplitud.Text);
double fase =
double.Parse(
((ConfiguracionSeñalSenoidal)
(panelConfiguracion.Children[0])).txtFase.Text
);
double frecuencia =
double.Parse(
((ConfiguracionSeñalSenoidal)
(panelConfiguracion.Children[0])).txtFrecuencia.Text
);
señal =
new SeñalSenoidal(amplitud, fase, frecuencia);
break;
case 2:
string rutaArchivo =
((ConfiguracionAudio)
(panelConfiguracion.Children[0])).txtRutaArchivo.Text;
señal = new SeñalAudio(rutaArchivo);
txtTiempoInicial.Text =
señal.TiempoInicial.ToString();
txtTiempoFinal.Text =
señal.TiempoFinal.ToString();
txtFrecuenciaMuestreo.Text =
señal.FrecuenciaMuestreo.ToString();
break;
default:
señal = null;
break;
}
if (cbTipoSeñal.SelectedIndex != 2 &&
señal != null)
{
señal.TiempoInicial =
tiempoInicial;
señal.TiempoFinal =
tiempoFinal;
señal.FrecuenciaMuestreo =
frecuenciaMuestreo;
señal.construirSeñal();
}
//Construir segunda señal si es necesario
if (cbOperacion.SelectedIndex == 2 | cbOperacion.SelectedIndex == 4)
{
switch (cbTipoSeñal_2.SelectedIndex)
{
case 0: // Parabolica
segundaSeñal = new SeñalParabolica();
break;
case 1: //Senoidal
double amplitud =
double.Parse(
((ConfiguracionSeñalSenoidal)
(panelConfiguracion_2.Children[0])).txtAmplitud.Text);
double fase =
double.Parse(
((ConfiguracionSeñalSenoidal)
(panelConfiguracion_2.Children[0])).txtFase.Text
);
double frecuencia =
double.Parse(
((ConfiguracionSeñalSenoidal)
(panelConfiguracion_2.Children[0])).txtFrecuencia.Text
);
segundaSeñal =
new SeñalSenoidal(amplitud, fase, frecuencia);
break;
case 2:
string rutaArchivo =
((ConfiguracionAudio)
(panelConfiguracion_2.Children[0])).txtRutaArchivo.Text;
segundaSeñal = new SeñalAudio(rutaArchivo);
txtTiempoInicial.Text =
segundaSeñal.TiempoInicial.ToString();
txtTiempoFinal.Text =
segundaSeñal.TiempoFinal.ToString();
txtFrecuenciaMuestreo.Text =
segundaSeñal.FrecuenciaMuestreo.ToString();
break;
default:
segundaSeñal = null;
break;
}
if (cbTipoSeñal_2.SelectedIndex != 2 && segundaSeñal != null)
{
segundaSeñal.TiempoInicial = tiempoInicial;
segundaSeñal.TiempoFinal = tiempoFinal;
segundaSeñal.FrecuenciaMuestreo = frecuenciaMuestreo;
segundaSeñal.construirSeñal();
}
}
switch (cbOperacion.SelectedIndex)
{
case 0: //Escala de amplitud
double factorEscala =
double.Parse(
((OperacionEscalaAmplitud)
(panelConfiguracionOperacion.
Children[0])).txtFactorEscala
.Text);
señalResultante =
Señal.escalarAmplitud(señal,
factorEscala);
break;
case 1:
double factorDesplazamiento =
double.Parse(((DesplazamientoAmplitud)(panelConfiguracionOperacion.Children[0]))
.txtFactorDesplazamiento.Text);
señalResultante = Señal.desAmplitud(señal, factorDesplazamiento);
break;
case 2:
señalResultante = Señal.multiplicarSeñales(señal, segundaSeñal);
break;
case 3:
double factorExponencial =
double.Parse(((OperacionEscalaExponencial)(panelConfiguracionOperacion.Children[0]))
.txtFactorExponente.Text);
señalResultante = Señal.escalaExponencial(señal, factorExponencial);
break;
case 4:
señalResultante = Señal.adicionarSeñales(señal, segundaSeñal);
break;
case 5: //Transf. de Fourier
señalResultante = Señal.transformadaFourier(señal);
break;
default:
señalResultante = null;
break;
}
/////AQUI ME QUEDE
//Operador ternario
//Evalua condicion. Si si y Si no
//Elige entre la primera y la resultante
double amplitudMaxima =
(señal.AmplitudMaxima >= señalResultante.AmplitudMaxima) ?
señal.AmplitudMaxima : señalResultante.AmplitudMaxima;
//Elige entre la mas grande de la 1ra y resultante y la segunda
if (segundaSeñal != null)
{
amplitudMaxima = (amplitudMaxima > segundaSeñal.AmplitudMaxima) ?
amplitudMaxima : segundaSeñal.AmplitudMaxima;
}
plnGrafica.Points.Clear();
plnGraficaResultante.Points.Clear();
plnGrafica_2.Points.Clear();
if (segundaSeñal != null)
{
foreach (var muestra in segundaSeñal.Muestras)
{
plnGrafica_2.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoInicial, amplitudMaxima));
}
}
foreach (Muestra muestra in señal.Muestras)
{
plnGrafica.Points.Add(
adaptarCoordenadas(muestra.X,
muestra.Y, tiempoInicial, amplitudMaxima)
);
}
foreach (Muestra muestra in señalResultante.Muestras)
{
plnGraficaResultante.Points.Add(
adaptarCoordenadas(muestra.X,
muestra.Y, tiempoInicial, amplitudMaxima)
);
}
if (cbOperacion.SelectedIndex == 5)
{
int indeceMaximo = 0;
for (int i = 0; i < (señalResultante.Muestras.Count / 2); i++)
{
if (señalResultante.Muestras[i].Y > señalResultante.Muestras[indeceMaximo].Y)
{
indeceMaximo = i;
}
}
lblHertz.Text = ((indeceMaximo * frecuenciaMuestreo) / (señal.Muestras.Count)).ToString("N") + "Hz";
}
lblLimiteSuperior.Text =
amplitudMaxima.ToString("F");
lblLimiteInferior.Text =
"-" + amplitudMaxima.ToString("F");
lblLimiteSuperiorResultante.Text =
amplitudMaxima.ToString("F");
lblLimiteInferiorResultante.Text = "-" +
amplitudMaxima.ToString("F");
//Original
plnEjeX.Points.Clear();
plnEjeX.Points.Add(
adaptarCoordenadas(tiempoInicial, 0.0,
tiempoInicial, amplitudMaxima)
);
plnEjeX.Points.Add(
adaptarCoordenadas(tiempoFinal, 0.0, tiempoInicial,
amplitudMaxima)
);
//Resultado
plnEjeXResultante.Points.Clear();
plnEjeXResultante.Points.Add((
adaptarCoordenadas(tiempoInicial, 0.0,
tiempoInicial, amplitudMaxima)));
plnEjeXResultante.Points.Add(
adaptarCoordenadas(tiempoFinal, 0.0,
tiempoInicial, amplitudMaxima));
//ver el cambio de como afecto la escala de la grafica
//Original
plnEjeY.Points.Clear();
plnEjeY.Points.Add(
adaptarCoordenadas(0.0, amplitudMaxima,
tiempoInicial, amplitudMaxima));
plnEjeY.Points.Add(
adaptarCoordenadas(0.0, amplitudMaxima * -1,
tiempoInicial, amplitudMaxima));
//Resultado
plnEjeYResultante.Points.Clear();
plnEjeYResultante.Points.Add(
adaptarCoordenadas(0.0, amplitudMaxima,
tiempoInicial, amplitudMaxima)
);
plnEjeYResultante.Points.Add(
adaptarCoordenadas(0.0, amplitudMaxima * -1,
tiempoInicial, amplitudMaxima)
);
}
private void btnGraficar_Click(object sender, RoutedEventArgs e)
{
double tiempoInicial = double.Parse(txtTiempoInicial.Text);
double tiempoFinal = double.Parse(txtTiempoFinal.Text);
double frecuenciaMuestreo = double.Parse(txtFrecuenciaMuestreo.Text);
double umbral = double.Parse(txtUmbral.Text);
double umbral_segundaSeñal = double.Parse(txtUmbral_SegundaSeñal.Text);
//PRIMERA SEÑAL
switch (cbTipoSeñal.SelectedIndex)
{
//Señal Senoidal
case 0:
double amplitud = double.Parse(((ConfiguracionSeñalSenoidal)
panelConfiguracion.Children[0]).txtAmplitud.Text);
double fase = double.Parse(((ConfiguracionSeñalSenoidal)
panelConfiguracion.Children[0]).txtFase.Text);
double frecuencia = double.Parse(((ConfiguracionSeñalSenoidal)
panelConfiguracion.Children[0]).txtFrecuencia.Text);
señal = new SeñalSenoidal(amplitud, fase, frecuencia, umbral); //constructor
break;
//Rampa
case 1: señal = new SeñalRampa();
break;
//Exponencial
case 2:
double alpha = double.Parse(((ConfiguracionSeñalExponencial)
panelConfiguracion.Children[0]).txtAlpha.Text);
señal = new SeñalExponencial(alpha, umbral);
break;
case 3:
señal = new SeñalRectangular();
break;
default:
señal = null;
break;
}
//SEGUNDA SEÑAL
switch (cbTipoSeñal_SegundaSeñal.SelectedIndex)
{
//Señal Senoidal
case 0:
double amplitud = double.Parse(((ConfiguracionSeñalSenoidal)
panelConfiguracion_SegundaSeñal.Children[0]).txtAmplitud.Text);
double fase = double.Parse(((ConfiguracionSeñalSenoidal)
panelConfiguracion_SegundaSeñal.Children[0]).txtFase.Text);
double frecuencia = double.Parse(((ConfiguracionSeñalSenoidal)
panelConfiguracion_SegundaSeñal.Children[0]).txtFrecuencia.Text);
segundaSeñal = new SeñalSenoidal(amplitud, fase, frecuencia, umbral); //constructor
break;
//Rampa
case 1:
segundaSeñal = new SeñalRampa();
break;
//Exponencial
case 2:
double alpha = double.Parse(((ConfiguracionSeñalExponencial)
panelConfiguracion_SegundaSeñal.Children[0]).txtAlpha.Text);
segundaSeñal = new SeñalExponencial(alpha, umbral);
break;
case 3:
segundaSeñal = new SeñalRectangular();
break;
default:
segundaSeñal = null;
break;
}
//---------------------------------PRIMERA SEÑAL------------------------------------------------------//
señal.TiempoInicial = tiempoInicial;
señal.TiempoFinal = tiempoFinal;
señal.FrecuenciaMuestreo = frecuenciaMuestreo;
señal.construirSeñalDigital();
//Escalar
double factorEscala = double.Parse(txtFactorEscalaAmplitud.Text);
señal.escalar(factorEscala);
//Desplazamiento
double desplazar = double.Parse(txtDesplazamientoY.Text);
señal.desplazarY(desplazar);
//Truncar
//señal.truncar(umbral);
//------------------------------------SEGUNDA SEÑAL--------------------------------------------------//
segundaSeñal.TiempoInicial = tiempoInicial;
segundaSeñal.TiempoFinal = tiempoFinal;
segundaSeñal.FrecuenciaMuestreo = frecuenciaMuestreo;
segundaSeñal.construirSeñalDigital();
//Escalar
double factorEscala_segundaSeñal = double.Parse(txtFactorEscalaAmplitud_SegundaSeñal.Text);
segundaSeñal.escalar(factorEscala_segundaSeñal);
//Desplazamiento
double desplazar_segundaSeñal = double.Parse(txtDesplazamientoY_SegundaSeñal.Text);
segundaSeñal.desplazarY(desplazar_segundaSeñal);
//Truncar
//segundaSeñal.truncar(umbral_segundaSeñal);
señal.actualizarAmplitudMaxima();
segundaSeñal.actualizarAmplitudMaxima();
amplitudMaxima = señal.AmplitudMaxima;
if (segundaSeñal.AmplitudMaxima > amplitudMaxima)
{
amplitudMaxima = segundaSeñal.AmplitudMaxima;
}
plnGrafica.Points.Clear();
plnGrafica2.Points.Clear();
lblAmplitudMaximaY.Text = amplitudMaxima.ToString("F");
lblAmplitudMaximaNegativaY.Text = "-" + amplitudMaxima.ToString("F");
//PRIMERA SEÑAL
if (señal != null)
{
//Recorre todos los elementos de una coleccion o arreglo
foreach (Muestra muestra in señal.Muestras)
{
plnGrafica.Points.Add(new Point((muestra.X - tiempoInicial) * scrContenedor.Width, (muestra.Y /
amplitudMaxima * ((scrContenedor.Height / 2.0) - 30) * -1) +
(scrContenedor.Height / 2)));
}
}
//SEGUNDA SEÑAL
if (segundaSeñal != null)
{
//Recorre todos los elementos de una coleccion o arreglo
foreach (Muestra muestra in segundaSeñal.Muestras)
{
plnGrafica2.Points.Add(new Point((muestra.X - tiempoInicial) * scrContenedor.Width, (muestra.Y /
amplitudMaxima * ((scrContenedor.Height / 2.0) - 30) * -1) +
(scrContenedor.Height / 2)));
}
}
plnEjeX.Points.Clear();
//Punto del principio
plnEjeX.Points.Add(new Point(0, (scrContenedor.Height / 2)));
//Punto del final
plnEjeX.Points.Add(new Point((tiempoFinal - tiempoInicial) * scrContenedor.Width,
(scrContenedor.Height / 2)));
plnEjeY.Points.Clear();
//Punto del principio
plnEjeY.Points.Add(new Point((0 - tiempoInicial) * scrContenedor.Width, (señal.AmplitudMaxima *
((scrContenedor.Height / 2.0) - 30) * -1) + (scrContenedor.Height / 2)));
//Punto del final
plnEjeY.Points.Add(new Point((0 - tiempoInicial) * scrContenedor.Width, (-señal.AmplitudMaxima *
((scrContenedor.Height / 2.0) - 30) * -1) + (scrContenedor.Height / 2)));
}
private void BtnGraficar_Click(object sender, RoutedEventArgs e)
{
double tiempoInicial = double.Parse(txtTiempoInicial.Text);
double tiempoFinal = double.Parse(txtTiempoFinal.Text);
double frecuenciaMuestreo = double.Parse(txtFrecuenciaMuestreo.Text);
Señal señal;
Señal segundaSeñal = null;
Señal señalResultante;
switch (cbTipoSeñal.SelectedIndex)
{
case 0: //parabólica
señal = new SeñalParabolica();
break;
case 1: //senoidal
double amplitud = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txtAmplitud.Text);
double fase = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txtFase.Text);
double frecuencia = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txtFrecuencia.Text);
señal = new SeñalSenoidal(amplitud, fase, frecuencia);
break;
case 2: //función signo
señal = new FuncionSigno();
break;
case 3: //exponencial alfa
double alfa = double.Parse(((ConfiguracionSeñalExponencialAlfa)(panelConfiguracion.Children[0])).txtAlfa.Text);
señal = new Exponencial_Alfa(alfa);
break;
case 4: //audio
string rutaArchivo = ((ConfiguracionAudio)(panelConfiguracion.Children[0])).txtRutaArchivo.Text;
señal = new SeñalAudio(rutaArchivo);
txtTiempoInicial.Text = señal.TiempoInicial.ToString();
txtTiempoFinal.Text = señal.TiempoFinal.ToString();
txtFrecuenciaMuestreo.Text = señal.FrecuenciaMuestreo.ToString();
break;
default:
señal = null;
break;
}
if (cbTipoSeñal.SelectedIndex != 4 && señal != null)
{
señal.TiempoFinal = tiempoFinal;
señal.TiempoInicial = tiempoInicial;
señal.FrecuenciaMuestreo = frecuenciaMuestreo;
señal.construirSeñal();
}
//construir segunda señal
if (cbOperacion.SelectedIndex == 2 || cbOperacion.SelectedIndex == 4)
{
switch (cbTipoSeñal2.SelectedIndex)
{
case 0: //Parabolica
segundaSeñal = new SeñalParabolica();
break;
case 1: //senoidal
double amplitud = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion2.Children[0])).txtAmplitud.Text);
double fase = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion2.Children[0])).txtFase.Text);
double frecuencia = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion2.Children[0])).txtFrecuencia.Text);
segundaSeñal = new SeñalSenoidal(amplitud, fase, frecuencia);
break;
case 2: //función signo
segundaSeñal = new FuncionSigno();
break;
case 3: //Exponencial
double alfa = double.Parse(((ConfiguracionSeñalExponencialAlfa)(panelConfiguracion2.Children[0])).txtAlfa.Text);
segundaSeñal = new Exponencial_Alfa(alfa);
break;
case 4: //Audio
string rutaArchivo = ((ConfiguracionAudio)(panelConfiguracion2.Children[0])).txtRutaArchivo.Text;
segundaSeñal = new SeñalAudio(rutaArchivo);
txtTiempoInicial.Text = segundaSeñal.TiempoInicial.ToString();
txtTiempoFinal.Text = segundaSeñal.TiempoFinal.ToString();
txtFrecuenciaMuestreo.Text = segundaSeñal.FrecuenciaMuestreo.ToString();
break;
default:
segundaSeñal = null;
break;
}
if (cbTipoSeñal2.SelectedIndex != 4 && segundaSeñal != null)
{
segundaSeñal.TiempoInicial = tiempoInicial;
segundaSeñal.TiempoFinal = tiempoFinal;
segundaSeñal.FrecuenciaMuestreo = frecuenciaMuestreo;
segundaSeñal.construirSeñal();
}
}
switch (cbOperacion.SelectedIndex)
{
case 0: //escala de amplitud
double factorEscala = double.Parse(((ConfiguracionOperacionEscalaAmplitud)(panelConfiguracionOperacion.Children[0])).txtFactorEscala.Text);
señalResultante = Señal.escalarAmplitud(señal, factorEscala);
break;
case 1: //desplazamiento
double cantidadDesplazamiento = double.Parse(((ConfiguracionOperacionDesplazamiento)(panelConfiguracionOperacion.Children[0])).txtCantidadDesplazamiento.Text);
señalResultante = Señal.desplazamientoAmplitud(señal, cantidadDesplazamiento);
break;
case 2: //multiplicacion
señalResultante = Señal.multiplicarSeñales(señal, segundaSeñal);
break;
case 3: //escala exponencial
double exponente = double.Parse(((ConfiguracionOperacionEscalaExponencial)(panelConfiguracionOperacion).Children[0]).txtExponente.Text);
señalResultante = Señal.escalaExponenecial(señal, exponente);
break;
case 4: //limite superior
señalResultante = Señal.limiteSuperior(señal, segundaSeñal);
break;
default:
señalResultante = null;
break;
}
//Elige entre la primera y la resultante
double amplitudMaxima = (señal.AmplitudMaxima >= señalResultante.AmplitudMaxima) ?
señal.AmplitudMaxima : señalResultante.AmplitudMaxima;
if (segundaSeñal != null)
{
//elige entre la mas grande de la 1ra y resultante y la segunda
amplitudMaxima = (amplitudMaxima > segundaSeñal.AmplitudMaxima) ? amplitudMaxima : segundaSeñal.AmplitudMaxima;
}
plnGrafica.Points.Clear();
plnGraficaResultante.Points.Clear();
foreach (Muestra muestra in señal.Muestras)
{
plnGrafica.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoInicial, amplitudMaxima));
}
foreach (Muestra muestra in señalResultante.Muestras)
{
plnGraficaResultante.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoInicial, amplitudMaxima));
}
lblAmplitudSuperior.Text = amplitudMaxima.ToString("F");
lblAmplitudInferior.Text = "-" + amplitudMaxima.ToString("F");
lblAmplitudResultanteSuperior.Text = amplitudMaxima.ToString("F");
lblAmplitudResultanteInferior.Text = "-" + amplitudMaxima.ToString("F");
plnEjeX.Points.Clear();
plnEjeX.Points.Add(adaptarCoordenadas(tiempoInicial, 0.0, tiempoInicial, amplitudMaxima));
plnEjeX.Points.Add(adaptarCoordenadas(tiempoFinal, 0.0, tiempoInicial, amplitudMaxima));
plnEjeY.Points.Clear();
plnEjeY.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoInicial, amplitudMaxima));
plnEjeY.Points.Add(adaptarCoordenadas(0.0, -amplitudMaxima, tiempoInicial, amplitudMaxima));
plnEjeXResultante.Points.Clear();
plnEjeXResultante.Points.Add(adaptarCoordenadas(tiempoInicial, 0.0, tiempoInicial, amplitudMaxima));
plnEjeXResultante.Points.Add(adaptarCoordenadas(tiempoFinal, 0.0, tiempoInicial, amplitudMaxima));
plnEjeYResultante.Points.Clear();
plnEjeYResultante.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoInicial, amplitudMaxima));
plnEjeYResultante.Points.Add(adaptarCoordenadas(0.0, -amplitudMaxima, tiempoInicial, amplitudMaxima));
}