Ejemplo n.º 1
0
        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)));
        }
Ejemplo n.º 2
0
        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)));
        }
Ejemplo n.º 4
0
        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));
        }
Ejemplo n.º 6
0
        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)));
        }
Ejemplo n.º 7
0
        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));
        }
Ejemplo n.º 9
0
        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);
        }
Ejemplo n.º 10
0
        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);
        }
Ejemplo n.º 11
0
        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));
        }
Ejemplo n.º 13
0
        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);
        }
Ejemplo n.º 14
0
        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);
        }
Ejemplo n.º 15
0
        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);
        }
Ejemplo n.º 16
0
        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);
        }
Ejemplo n.º 17
0
        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);
        }
Ejemplo n.º 18
0
        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);
        }
Ejemplo n.º 19
0
        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);
        }
Ejemplo n.º 20
0
        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);
        }
Ejemplo n.º 21
0
        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);
        }
Ejemplo n.º 22
0
        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);
        }
Ejemplo n.º 23
0
        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);
        }
Ejemplo n.º 24
0
        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);
        }
Ejemplo n.º 25
0
        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);
        }
Ejemplo n.º 26
0
        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)
                );
        }
Ejemplo n.º 29
0
        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));
        }