Beispiel #1
0
        private void btnGraficar_Click(object sender, RoutedEventArgs e)
        {
            //para obtener el valor del text box se usa la propiedad .Text

            double tiempoInicial      = double.Parse(txtTiempoInicial.Text);
            double tiempoFinal        = double.Parse(txtTiempoFinal.Text);
            double frecuenciaMuestreo = double.Parse(txtFrecuenciaMuestreo.Text);

            //instancia de la clase señal senoidal
            Señal señal;

            switch (cbTipoSeñal.SelectedIndex)
            {
            //señal senoidal
            case 0:
                //el primer hijo del panel configuracion es la configuracion senoidal y es de otro tipo (ui collection)asi que se hace un casting y asi se puede acceder a sus propiedades, ademas como txtamplitud es tipo texto se usa parse
                //nota: los hijos son los elementos de los contenedores
                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;

            default:
                señal = null;
                break;
            }

            //se establecen los valores para la funcion
            señal.TiempoInicial      = tiempoInicial;
            señal.TiempoFinal        = tiempoFinal;
            señal.FrecuenciaMuestreo = frecuenciaMuestreo;


            //se ejecuta la funcion
            señal.construirSeñalDigital();

            if ((bool)cbAmplitud.IsChecked)
            {
                //Escalar
                double factorEscala = double.Parse(txtFactorEscalaAmplitud.Text);
                señal.escalar(factorEscala);
            }

            if ((bool)cbDesplazar.IsChecked)
            {
                //Desplazar
                double factorDesplazar = double.Parse(txtFactorDesplazamiento.Text);
                señal.desplazar(factorDesplazar);
            }

            if ((bool)cbTruncar.IsChecked)
            {
                //Truncar
                double factorTruncar = double.Parse(txtFactorTruncar.Text);
                señal.truncar(factorTruncar);
            }

            if ((bool)cbExponente.IsChecked)
            {
                //Truncar
                double factorExponente = double.Parse(txtFactorExponente.Text);
                señal.exponente(factorExponente);
            }

            // limpiar la grafica
            plnGrafica.Points.Clear();


            if (señal != null)
            {
                //recorrer una coleccion o arreglo
                //muestra toma el valor de señal.muestra en cada recorrido del ciclo
                foreach (Muestra muestra in señal.Muestras)
                {
                    //se evalua la señal, luego se ajusta y de ahi se agrega el punto
                    plnGrafica.Points.Add(new Point((muestra.X - tiempoInicial) * scrContenedor.Width, (muestra.Y / señal.AmplitudMaxima * ((scrContenedor.Height / 2) - 30) * -1) + (scrContenedor.Height / 2)));
                }

                //cambiar los valores de la etiqueta
                lblAmplitudMaximaPositivaY.Text = señal.AmplitudMaxima.ToString();
                lblAmplitudMaximaNegativaY.Text = "-" + señal.AmplitudMaxima.ToString();
            }

            //Graficando el eje de X
            plnEjeX.Points.Clear();
            //Punto de inicio.
            plnEjeX.Points.Add(new Point(0, (scrContenedor.Height / 2)));
            //Punto de fin.
            plnEjeX.Points.Add(new Point((tiempoFinal - tiempoInicial) * scrContenedor.Width, (scrContenedor.Height / 2)));

            //Graficando el eje de Y
            plnEjeY.Points.Clear();
            //Punto de inicio.
            plnEjeY.Points.Add(new Point(0 - tiempoInicial * scrContenedor.Width, scrContenedor.Height));
            //Punto de fin.
            plnEjeY.Points.Add(new Point(0 - tiempoInicial * scrContenedor.Width, scrContenedor.Height * -1));
        }
        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);

            Señal 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;

            case 2:
                double alpha = double.Parse(((ConfiguracionSeñalExponencial)
                                             panelConfiguracion.Children[0]).txtAlpha.Text);

                señal = new SeñalExponencial(alpha, umbral);
                break;

            default:

                señal = null;

                break;
            }

            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);

            //Potencia
            double potencia = double.Parse(txtPotencia.Text);

            señal.potenciar(potencia);

            señal.actualizarAmplitudMaxima();


            plnGrafica.Points.Clear();

            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 /
                                                                                                        señal.AmplitudMaxima * ((scrContenedor.Height / 2.0) - 30) * -1) +
                                                    (scrContenedor.Height / 2)));
                }

                lblAmplitudMaximaY.Text         = señal.AmplitudMaxima.ToString();
                lblAmplitudMaximaNegativaY.Text = "-" + señal.AmplitudMaxima.ToString();
            }

            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:     //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:     //Exponencial
                double alpha = double.Parse(((ConfiguracionSeñalExponencial)(panelConfiguracion.Children[0])).txtAlpha.Text);
                señal = new SeñalExponencial(alpha);
                break;

            case 3:     //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 != 3 && señal != null)
            {
                señal.TiempoInicial      = tiempoInicial;
                señal.TiempoFinal        = tiempoFinal;
                señal.FrecuenciaMuestreo = frecuenciaMuestreo;
                señal.constriurSeñal();
            }
            //Construir segunda señal si es necesario
            if (cbOperacion.SelectedIndex == 2)
            {
                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:     //Exponencial
                    double alpha = double.Parse(((ConfiguracionSeñalExponencial)(panelConfiguracion_2.Children[0])).txtAlpha.Text);
                    segundaSeñal = new SeñalExponencial(alpha);
                    break;

                case 3:     //Audio
                    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 != 3 && segundaSeñal != null)
                {
                    segundaSeñal.TiempoInicial      = tiempoInicial;
                    segundaSeñal.TiempoFinal        = tiempoFinal;
                    segundaSeñal.FrecuenciaMuestreo = frecuenciaMuestreo;
                    segundaSeñal.constriurSeñ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:     //Desplazamiento de Amplitud
                double cantidadDesplazamiento = double.Parse(((OperacionDesplazamientoAmplitud)
                                                              (panelConfiguracionOperacion.Children[0])).txtDesplazamiento.Text);
                señalResultante = Señal.desplazarAmplitud(señal, cantidadDesplazamiento);
                break;

            case 2:     //Multiplicacion de señales
                señalResultante = Señal.multiplicarSeñales(señal, segundaSeñal);
                break;

            case 3:     //Escala exponencial
                double exponente = double.Parse(((OperacionEscalaExponencial)
                                                 (panelConfiguracionOperacion.Children[0])).txtExponente.Text);
                señalResultante = Señal.escalaExponencial(señal, exponente);
                break;

            case 4:     //transformada de Fourier
                señalResultante = Señal.transformadaFourier(señ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();
            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 == 4)
            {
                int indiceMaximo  = 0;
                int indiceInicial = (int)((690.0 * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                int indiceFinal   = (int)((950.0 * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                //Frecuancia Baja
                for (int i = indiceInicial; i < indiceFinal; i++)
                {
                    if (señalResultante.Muestras[i].Y > señalResultante.Muestras[indiceMaximo].Y)
                    {
                        indiceMaximo = i;
                    }
                }
                double frecuencia = (double)(indiceMaximo * señalResultante.FrecuenciaMuestreo) / (double)señalResultante.Muestras.Count;
                lblHz_Baja.Text = frecuencia.ToString("N") + " Hz";
                //Frecuencia Alta
                int indiceInicialAlta = (int)((1200.0 * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                int indiceFinalAlta   = (int)((1482.0 * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                int indiceMaximoAlta  = 0;

                for (int i = indiceInicialAlta; i < indiceFinalAlta; i++)
                {
                    if (señalResultante.Muestras[i].Y > señalResultante.Muestras[indiceMaximoAlta].Y)
                    {
                        indiceMaximoAlta = i;
                    }
                }
                double frecuenciaAlta = (double)(indiceMaximoAlta * señalResultante.FrecuenciaMuestreo) / (double)señalResultante.Muestras.Count;
                lblHz_Alta.Text = frecuenciaAlta.ToString("N") + " Hz";
                if (frecuencia > 695 && frecuencia < 699)
                {
                    if (frecuenciaAlta > 1207 && frecuenciaAlta < 1211)
                    {
                        lblTecla.Text = "1";
                    }
                    if (frecuenciaAlta > 1334 && frecuenciaAlta < 1338)
                    {
                        lblTecla.Text = "2";
                    }
                    if (frecuenciaAlta > 1475 && frecuenciaAlta < 1479)
                    {
                        lblTecla.Text = "3";
                    }
                }
                if (frecuencia > 768 && frecuencia < 772)
                {
                    if (frecuenciaAlta > 1207 && frecuenciaAlta < 1211)
                    {
                        lblTecla.Text = "4";
                    }
                    if (frecuenciaAlta > 1334 && frecuenciaAlta < 1338)
                    {
                        lblTecla.Text = "5";
                    }
                    if (frecuenciaAlta > 1475 && frecuenciaAlta < 1479)
                    {
                        lblTecla.Text = "6";
                    }
                }
                if (frecuencia > 850 && frecuencia < 854)
                {
                    if (frecuenciaAlta > 1207 && frecuenciaAlta < 1211)
                    {
                        lblTecla.Text = "7";
                    }
                    if (frecuenciaAlta > 1334 && frecuenciaAlta < 1338)
                    {
                        lblTecla.Text = "8";
                    }
                    if (frecuenciaAlta > 1475 && frecuenciaAlta < 1479)
                    {
                        lblTecla.Text = "9";
                    }
                }
                if (frecuencia > 939 && frecuencia < 943)
                {
                    if (frecuenciaAlta > 1207 && frecuenciaAlta < 1211)
                    {
                        lblTecla.Text = "*";
                    }
                    if (frecuenciaAlta > 1334 && frecuenciaAlta < 1338)
                    {
                        lblTecla.Text = "0";
                    }
                    if (frecuenciaAlta > 1475 && frecuenciaAlta < 1479)
                    {
                        lblTecla.Text = "#";
                    }
                }
            }

            //Original
            lblLimiteSuperior.Text = amplitudMaxima.ToString("F");
            lblLimiteInferior.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));
            //Resultado
            lblLimiteSuperiorResultante.Text = amplitudMaxima.ToString("F");
            lblLimiteInferiorResultado.Text  = "-" + amplitudMaxima.ToString("F");
            plnEjeXResultante.Points.Clear();
            plnEjeXResultante.Points.Add(adaptarCoordenadas(tiempoFinal, 0.0, tiempoInicial, amplitudMaxima));
            plnEjeXResultante.Points.Add(adaptarCoordenadas(tiempoInicial, 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));
        }
        private void BtnGraficar_Click(object sender, RoutedEventArgs e)
        {
            //Convertidor de texto a int
            double tiempoInicial = double.Parse(txtTiempoInicial.Text);
            double tiempoFinal = double.Parse(txtTiempoFinal.Text);
            double frecuenciaMuestreo = double.Parse(txtFrecuenciaMuestreo.Text);

            //SeñalSenoidal señal = new SeñalSenoidal(amplitud, fase, frecuencia);
            //SeñalParabolica señal = new SeñalParabolica();
            //FuncionSigno señal = new FuncionSigno();
            Señal señal; //polimorfismo: que clases actuen como otras clases
            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: //Exponencial
                    double alpha = double.Parse(((ConfigurcionExponencial)(panelConfiguracion.Children[0])).txtAlpha.Text);
                    señal = new SeñalExponencial(alpha);
                    break;
                case 3: //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 != 3 && 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)
            {
                switch (cbTipoSeñal_2.SelectedIndex)
                {
                    case 0: //Parabólica
                        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: //Exponencial
                        double alpha = double.Parse(((ConfigurcionExponencial)(panelConfiguracion_2.Children[0])).txtAlpha.Text);
                        segundaSeñal = new SeñalExponencial(alpha);
                        break;
                    case 3: //Audio
                        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:  //Desplazamiento de amplitud
                    double cantidadDesplazamiento = double.Parse(((DesplazamientoAmplitud)(panelConfiguracionOperacion.Children[0])).txtCantidadDesplazamiento.Text);
                    señalResultante = Señal.desplazamientoAmplitud(señal, cantidadDesplazamiento);
                    break;
                case 2:  //Multiplicacion de señales
                    señalResultante = Señal.multiplicarSeñales(señal, segundaSeñal);
                    break;
                case 3: //Escala resultante
                    double exponente = double.Parse(((OperacionEscalaExponencial)(panelConfiguracionOperacion.Children[0])).txtExponente.Text);
                    señalResultante = Señal.escalaExponencial(señal, exponente);
                    break;
                case 4:  //Transformada de Fourier
                    señalResultante = Señal.transformadaFourier(señal);
                    break;
                default:
                    señalResultante = null;
                    break;
            }
            //Operador ternario
            //Si una es mayor que la otra o sino-> 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 primera y la resultante y la segunda
                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));
                }
            }
            
            //Ayuda a recorrer todas las estructuras de datos que hay
            foreach (Muestra muestra in señal.Muestras)
            {
                plnGraficaResultante.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoInicial, amplitudMaxima));
            }
            foreach (Muestra muestra in señalResultante.Muestras)
            {
                plnGrafica.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoInicial, amplitudMaxima));
            }

            //Se recorre todo el arreglo de la transformada de fourier para encontrar el indice
            if(cbOperacion.SelectedIndex == 4)
            {
                //Se obtiene la frecuencia baja de la tecla
                int indiceMaximo = 0;
                int indiceInicial = (int)((690.0 * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                int indiceFinal= (int)((950.0 * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                for (int i=indiceInicial; i<indiceFinal; i++)
                {
                    if(señalResultante.Muestras[i].Y > señalResultante.Muestras[indiceMaximo].Y)
                    {
                        indiceMaximo = i;
                    }
                                    
                }
                double frecuencia = (double)(indiceMaximo * señalResultante.FrecuenciaMuestreo) / (double)señalResultante.Muestras.Count;
                //Pasar numero a "texto"
                lblHertzBaja.Text = frecuencia.ToString("N") + "Hz";
                //Se obtiene la frecuencia alta de la tecla
                int indiceMaximoAlta = 0;
                int indiceInicialAlta = (int)((1200.0 * (double)señalResultante.Muestras.Count) / (double)señalResultante.FrecuenciaMuestreo);
                int indiceFinalAlta = (int)((1482.0 * (double)señalResultante.Muestras.Count) / (double)señalResultante.FrecuenciaMuestreo);
                for (int i = indiceInicialAlta; i < indiceFinalAlta; i++)
                {
                    if (señalResultante.Muestras[i].Y > señalResultante.Muestras[indiceMaximoAlta].Y)
                    {
                        indiceMaximoAlta = i;
                    }
                }
                double frecuenciaAlta = (double)(indiceMaximoAlta * señalResultante.FrecuenciaMuestreo) / (double)señalResultante.Muestras.Count;
                lblHertzAlta.Text = frecuenciaAlta.ToString("N") + "Hz";

                //Se obtiene el numero de la tecla
                double tecla;
                if(frecuencia <= 690.0 && frecuenciaAlta <= )
                {
                    tecla = 1;
                    lblTecla.Text = tecla.ToString("N");
                }
                if(frecuencia )
            }
                        
            lblLimiteSuperior.Text = amplitudMaxima.ToString("F");
            lblLimiteInferior.Text = "-" + amplitudMaxima.ToString("F");

            lblLimiteInferiorResultante.Text = "-" + amplitudMaxima.ToString("F");
            lblLimiteSuperiorResultante.Text = amplitudMaxima.ToString("F");

            //Entre más muestras haya, más calidad en la gráfica hay <<Original>>
            plnEjeX.Points.Clear();
            plnEjeX.Points.Add(adaptarCoordenadas(tiempoInicial, 0.0, tiempoInicial, amplitudMaxima)); //Esto es para hacer la linea del eje de las X 
            plnEjeX.Points.Add(adaptarCoordenadas(tiempoFinal, 0.0, tiempoInicial, amplitudMaxima)); //Esto es para hacer la linea del eje de las X
            //<<Resultante>>
            plnEjeXResultante.Points.Clear();
            plnEjeXResultante.Points.Add(adaptarCoordenadas(tiempoInicial, 0.0, tiempoInicial, amplitudMaxima));
            plnEjeXResultante.Points.Add(adaptarCoordenadas(tiempoFinal, 0.0, tiempoInicial, amplitudMaxima));

            //Eje Y <<Original>>
            plnEjeY.Points.Clear();
            plnEjeY.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoInicial, amplitudMaxima));
            plnEjeY.Points.Add(adaptarCoordenadas(0.0, -amplitudMaxima, tiempoInicial, amplitudMaxima));
            //<<Resultante>>
            plnEjeYResultante.Points.Clear();
            plnEjeYResultante.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoInicial, amplitudMaxima));
            plnEjeYResultante.Points.Add(adaptarCoordenadas(0.0, -amplitudMaxima, tiempoInicial, amplitudMaxima));
            
        }
        private void BotonGraficar_Click(object sender, RoutedEventArgs e)
        {
            double tiempoInicial      = double.Parse(txt_TiempoInicial.Text);
            double tiempoFinal        = double.Parse(txt_TiempoFinal.Text);
            double frecuenciaMuestreo = double.Parse(txt_FrecuenciaDeMuestreo.Text);

            Señal señal;

            switch (cb_TipoSeñal.SelectedIndex)
            {
            // Señal Senoidal
            case 0:
                double amplitud   = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txt_Amplitud.Text);
                double fase       = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txt_Fase.Text);
                double frecuencia = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txt_Frecuencia.Text);

                señal = new SeñalSenoidal(amplitud, fase, frecuencia);
                break;

            // Señal Rampa
            case 1:
                señal = new SeñalRampa();
                break;

            // Señal Exponencial
            case 2:
                double alpha = double.Parse(((ConfiguracionSeñalExponencial)(panelConfiguracion.Children[0])).txt_Alpha.Text);
                señal = new SeñalExponencial(alpha);
                break;

            default:
                señal = null;
                break;
            }

            señal.TiempoInicial      = tiempoInicial;
            señal.TiempoFinal        = tiempoFinal;
            señal.FrecuenciaMuestreo = frecuenciaMuestreo;

            señal.construirSeñalDigital();

            // Escalar
            if ((bool)ckb_Escala.IsChecked)
            {
                double factorEscala = double.Parse(txt_EscalaAmplitud.Text);
                señal.escalar(factorEscala);
            }

            // Desplazar
            if ((bool)ckb_Desplazamiento.IsChecked)
            {
                double factorDesplazamiento = double.Parse(txt_Desplazamiento.Text);
                señal.desplazar(factorDesplazamiento);
            }

            // Truncar
            if ((bool)ckb_Truncado.IsChecked)
            {
                double n = double.Parse(txt_Truncado.Text);
                señal.truncar(n);
            }

            // Potenciar
            if ((bool)ckb_Potencia.IsChecked)
            {
                double n = Math.Abs(double.Parse(txt_Potencia.Text));
                señal.potenciar(n);
            }

            // Actualizar
            señal.actualizarAmplitudMaxima();

            plnGrafica.Points.Clear();

            if (señal != null)
            {
                // Sirve para recorrer una coleccion o arreglo
                foreach (Muestra muestra in señal.Muestras)
                {
                    plnGrafica.Points.Add(new Point((muestra.X - tiempoInicial) * scrContenedor.Width, (muestra.Y / señal.AmplitudMaxima * ((scrContenedor.Height / 2) - 30) * -1 + (scrContenedor.Height / 2))));
                }

                lbl_AmplitudMaxima.Text = señal.AmplitudMaxima.ToString();
                lbl_AmplitudMinima.Text = "-" + señal.AmplitudMaxima.ToString();
            }

            // Línea del Eje X
            plnEjeX.Points.Clear();
            plnEjeX.Points.Add(new Point(0, scrContenedor.Height / 2));
            plnEjeX.Points.Add(new Point((tiempoFinal - tiempoInicial) * scrContenedor.Width, scrContenedor.Height / 2));

            // Línea del Eje Y
            plnEjeY.Points.Clear();
            plnEjeY.Points.Add(new Point((-tiempoInicial) * scrContenedor.Width, 0));
            plnEjeY.Points.Add(new Point((-tiempoInicial) * scrContenedor.Width, scrContenedor.Height));
        }
        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;

            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;

            default:
                señal = null;
                break;
            }
            señal.TiempoInicial      = tiempoInicial;
            señal.TiempoFinal        = tiempoFinal;
            señal.FrecuenciaMuestreo = frecuenciaMuestreo;

            señal.construirSeñalDigital();

            //Escalar
            double FactorEscala = double.Parse(txtEscalaAmplitud.Text);

            señal.escalar(FactorEscala);

            double FactorDesplazarY = double.Parse(txtDesplazarY.Text);

            señal.desplazarY(FactorDesplazarY);

            //
            if ((bool)chTruncar.IsChecked)
            {
                //truncar
                float FactorUmbral = float.Parse(txtUmbral.Text);
                señal.truncar(FactorUmbral);
            }
            //
            //
            if ((bool)chPotencia.IsChecked)
            {
                //potencia
                float FactorPotencia = float.Parse(txtPotencia.Text);
                señal.potencia(FactorPotencia);
            }
            //

            señal.actualizarAmplitudMaxima();

            plnGrafica.Points.Clear();


            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 / señal.AmplitudMaxima) * ((scrContenedor.Height / 2.0) - 30) * -1)
                                                    + (scrContenedor.Height / 2)));
                }
                lblAmplitudMaximaY.Text         = señal.AmplitudMaxima.ToString();
                lblAmplitudMaximaNegativaY.Text = "-" + señal.AmplitudMaxima.ToString();
            }

            plnEjeX.Points.Clear();
            //Punto del Principio
            plnEjeX.Points.Add(new Point(0, (scrContenedor.Height / 2)));
            //Punto del Fin
            plnEjeX.Points.Add(new Point(((tiempoFinal - tiempoInicial) * scrContenedor.Width), (scrContenedor.Height / 2)));

            //Punto del Principio
            plnEjeY.Points.Add(new Point(0 - tiempoInicial * scrContenedor.Width, scrContenedor.Height));
            //Punto del Fin
            plnEjeY.Points.Add(new Point(0 - tiempoInicial * scrContenedor.Width, scrContenedor.Height * -1));
        }
        private void btnGraficar_Click(object sender, RoutedEventArgs e)
        {
            /*double amplitud =
             *  double.Parse(txtAmplitud.Text);
             * double fase =
             *  double.Parse(txtFase.Text);
             * double frecuencia =
             *  double.Parse(txtFrecuencia.Text);*/
            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 (cbTipoSenal.SelectedIndex)
            {
            case 0:     //parabolica
                señal = new SenalParabolica();
                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:     //exponencial
                double alfa = double.Parse(((ConfiguracionSeñalExponencial)(panelConfiguracion.Children[0])).txtAlfa.Text);

                señal = new SeñalExponencial(alfa);
                break;

            case 3:     //audio
                string rutaArchivo = ((ConfiguracionSeñalAudio)(panelConfiguracion.Children[0])).txtRutaArchivo.Text;
                señal = new SeñalAudio(rutaArchivo);

                txtTiempoInicial.Text = señal.TiempoInicial.ToString();
                txtTiempoFinal.Text   = señal.FrecuenciaMuestreo.ToString();

                break;

            default:
                señal = null;
                break;
            }

            if (cbTipoSenal.SelectedIndex != 3 && 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)
            {
                switch (cbTipoSenal_2.SelectedIndex)
                {
                case 0:     //parabolica
                    segundaSeñal = new SenalParabolica();
                    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:     //exponencial
                    double alfa = double.Parse(((ConfiguracionSeñalExponencial)(panelConfiguracion_2.Children[0])).txtAlfa.Text);

                    segundaSeñal = new SeñalExponencial(alfa);
                    break;

                case 3:     //audio
                    string rutaArchivo = ((ConfiguracionSeñalAudio)(panelConfiguracion_2.Children[0])).txtRutaArchivo.Text;
                    segundaSeñal = new SeñalAudio(rutaArchivo);

                    txtTiempoInicial.Text = segundaSeñal.TiempoInicial.ToString();
                    txtTiempoFinal.Text   = segundaSeñal.FrecuenciaMuestreo.ToString();

                    break;

                default:
                    señal = null;
                    break;
                }
                if (cbTipoSenal_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:     // desplazamiento
                double desplazamiento = double.Parse(((OperacionDesplazamiento)(panelConfiguracionOperacion.Children[0])).txtDesplazamiento.Text);
                señalResultante = Señal.desplazamintoSeñales(señal, desplazamiento);
                break;

            case 2:     //multiplicacion de señales
                señalResultante = Señal.multiplicarSeñales(señal, segundaSeñal);
                break;

            case 3:     //escala exponencial
                double exponente = double.Parse(((OperacionEscalaExponencial)(panelConfiguracionOperacion.Children[0])).txtExponente.Text);
                señalResultante = Señal.escalarExponencial(señal, exponente);
                break;

            case 4:     //transformada de fourier
                señalResultante = Señal.transformadaFourier(señal);
                break;

            default:
                señalResultante = null;
                break;
            }

            // elije entre la primera y la resultante
            double amplitudMaxima = (señal.AmplitudMaxima >= señalResultante.AmplitudMaxima) ?
                                    señal.AmplitudMaxima : señalResultante.AmplitudMaxima;

            if (segundaSeñal != null)
            {
                //elije entre la mas grande de la primera y resultante y la segunda
                amplitudMaxima = (amplitudMaxima > segundaSeñal.AmplitudMaxima) ?
                                 amplitudMaxima : segundaSeñal.AmplitudMaxima;
            }

            double periodoMuestreo = 1.0 / frecuenciaMuestreo;

            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 == 4)
            {
                int indiceMaximo = 0;
                for (int i = 0; i < señalResultante.Muestras.Count / 2; i++)
                {
                    if (señalResultante.Muestras[i].Y > señalResultante.Muestras[indiceMaximo].Y)
                    {
                        indiceMaximo = i;
                    }
                }
                double frecuencia = (double)(indiceMaximo * señalResultante.FrecuenciaMuestreo) /
                                    (double)señalResultante.Muestras.Count;
                lblHerz.Text = frecuencia.ToString("N") + " Hz";
            }

            lblLimiteSuperior.Text = amplitudMaxima.ToString("F");
            lblLimiteInferior.Text = "-" + amplitudMaxima.ToString("F");

            lblLimiteInferiorResultado.Text = "-" + amplitudMaxima.ToString("F");
            lblLimiteSuperiorResultado.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));

            plnEjeY.Points.Clear();
            plnEjeY.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoInicial, amplitudMaxima));
            plnEjeY.Points.Add(adaptarCoordenadas(0.0, -amplitudMaxima, tiempoInicial, amplitudMaxima));

            //resultado
            plnEjeYResultante.Points.Clear();
            plnEjeYResultante.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoInicial, amplitudMaxima));
            plnEjeYResultante.Points.Add(adaptarCoordenadas(0.0, -amplitudMaxima, tiempoInicial, amplitudMaxima));
        }
        private void BtnGraficar_Click(object sender, RoutedEventArgs e)
        {
            double frecuenciaMuestreo = double.Parse(txtFrecuenciaMuestreo.Text);
            double tiempoInicial      = double.Parse(txtTiempoInicial.Text);
            double tiempoFinal        = double.Parse(txtTiempoFinal.Text);


            //FuncionSigno señal = new FuncionSigno();
            Señal señal;
            //Segunda señal
            Señal señalResultante;

            switch (CbTipoSenal.SelectedIndex)
            {
            case 0:
                señal = new SeñalParabolica();
                break;

            case 1:    //Casteo y luego parse
                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:
                double alpha = double.Parse(
                    ((ConfiguaracionExponencial)(panelConfiguracion.Children[0])).txtAlpha.Text);
                señal = new SeñalExponencial(alpha);

                break;

            case 3:
                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 (CbTipoSenal.SelectedIndex != 3 && señal != null)
            {
                señal.TiempoInicial      = tiempoInicial;
                señal.TiempoFinal        = tiempoFinal;
                señal.FrecuenciaMuestreo = frecuenciaMuestreo;
                señal.construirSeña();
            }

            switch (cbOperacion.SelectedIndex)
            {
            case 0:    //Escala de Amplitud
                double factorEscala = double.Parse(((OperacionEscalaAmplitud)(panelConfiguracion.Children[0])).txtFactorEscala.Text);
                señalResultante = new Señal.escalarAmplitud(señal, factorEscala);
                break;

            default:
                señalResultante = null;
                break;
            }


            double amplitudMaxima          = señal.AmplitudMaxima;
            double amplitudMaximaResultado = señalResultante.AmplitudMaxima;

            plnGrafica.Points.Clear();
            plnGraficaResultante.Points.Clear();

            //para graficar los puntos
            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, amplitudMaximaResultado));
            }
            lbllimiteSuperior.Text            = amplitudMaxima.ToString("F");
            lbllimiteInferior.Text            = "-" + amplitudMaxima.ToString("F");
            lbllimiteSuperiorResultante.Text  = amplitudMaximaResultado.ToString("F");
            lbllimiteInferiorResulstante.Text = "-" + amplitudMaximaResultado.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 * -1, tiempoInicial, amplitudMaxima));

            //RESULTADO /2da grafica/
            plnEjeXResultante.Points.Clear();
            plnEjeXResultante.Points.Add(adaptarCoordenadas(tiempoInicial, 0.0, tiempoInicial, amplitudMaximaResultado));
            plnEjeXResultante.Points.Add(adaptarCoordenadas(tiempoFinal, 0.0, tiempoInicial, amplitudMaximaResultado));

            plnEjeYResultante.Points.Clear();
            plnEjeYResultante.Points.Add(adaptarCoordenadas(0.0, amplitudMaximaResultado, tiempoInicial, amplitudMaximaResultado));
            plnEjeYResultante.Points.Add(adaptarCoordenadas(0.0, amplitudMaximaResultado * -1, tiempoInicial, amplitudMaximaResultado));
        }
Beispiel #9
0
        private void BtnGraficar_Click(object sender, RoutedEventArgs e)
        {
            double tiempoInicial = double.Parse(txtbox_tiempoInicial.Text);
            double tiempoFinal   = double.Parse(txtbox_tiempoFinal.Text);
            double muestro       = double.Parse(txtbox_muestreo.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])).txtbox_amplitud.Text
                        );

                double fase =
                    double.Parse(
                        ((ConfiguracionSeñalSenoidal)(PanelConfiguracion.Children[0])).txtbox_fase.Text
                        );

                double frecuencia =
                    double.Parse(
                        ((ConfiguracionSeñalSenoidal)(PanelConfiguracion.Children[0])).txtbox_frecuencia.Text
                        );

                señal = new SeñalSenoidal(amplitud, fase, frecuencia);
                break;

            case 2:     //Exponencial
                double alpha =
                    double.Parse(
                        ((ConfiguracionSeñalExponencial)(PanelConfiguracion.Children[0])).txt_alpha.Text
                        );
                señal = new SeñalExponencial(alpha);
                break;

            case 3:     //Audio
                string rutaArchivo = ((ConfiguracionSeñalAudio)(PanelConfiguracion.Children[0])).txtRutaArchivo.Text;
                señal = new SeñalAudio(rutaArchivo);
                txtbox_tiempoInicial.Text = señal.TiempoInicial.ToString();
                txtbox_tiempoFinal.Text   = señal.TiempoFinal.ToString();
                txtbox_muestreo.Text      = señal.FrecuenciaMuestreo.ToString();
                break;

            default:
                señal = null;
                break;
            }

            if (CbTipoSeñal.SelectedIndex != 3)
            {
                señal.TiempoInicial      = tiempoInicial;
                señal.TiempoFinal        = tiempoFinal;
                señal.FrecuenciaMuestreo = muestro;

                señal.construirSeñal();
            }

            //Construir segunda señal si es necesario
            if (CbOperacion.SelectedIndex == 2)
            {
                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])).txtbox_amplitud.Text
                            );

                    double fase =
                        double.Parse(
                            ((ConfiguracionSeñalSenoidal)(PanelConfiguracion_2.Children[0])).txtbox_fase.Text
                            );

                    double frecuencia =
                        double.Parse(
                            ((ConfiguracionSeñalSenoidal)(PanelConfiguracion_2.Children[0])).txtbox_frecuencia.Text
                            );

                    segundaSeñal = new SeñalSenoidal(amplitud, fase, frecuencia);
                    break;

                case 2:     //Exponencial
                    double alpha =
                        double.Parse(
                            ((ConfiguracionSeñalExponencial)(PanelConfiguracion_2.Children[0])).txt_alpha.Text
                            );
                    señal = new SeñalExponencial(alpha);
                    break;

                case 3:     //Audio
                    string rutaArchivo = ((ConfiguracionSeñalAudio)(PanelConfiguracion_2.Children[0])).txtRutaArchivo.Text;
                    segundaSeñal = new SeñalAudio(rutaArchivo);
                    txtbox_tiempoInicial.Text = señal.TiempoInicial.ToString();
                    txtbox_tiempoFinal.Text   = señal.TiempoFinal.ToString();
                    txtbox_muestreo.Text      = señal.FrecuenciaMuestreo.ToString();
                    break;

                default:
                    señal = null;
                    break;
                }
                if (CbTipoSeñal_2.SelectedIndex != 2 && segundaSeñal != null)
                {
                    segundaSeñal.TiempoInicial      = tiempoInicial;
                    segundaSeñal.TiempoFinal        = tiempoFinal;
                    segundaSeñal.FrecuenciaMuestreo = muestro;
                    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.escalaAmplitud(señal, factorEscala);
                break;

            case 1:     //Desplazamiento de amplitud
                double factorDesplazamiento = double.Parse(
                    ((OperacionDesplazamientoAmplitud)(PanelConfiguracionOperacion.Children[0])).txtFactorDesplazamiento.Text
                    );
                señalResultante = Señal.desplazamientoAmplitud(señal, factorDesplazamiento);
                break;

            case 2:     //Multiplicacion de señales
                señalResultante = Señal.multiplicarSeñales(señal, segundaSeñal);
                break;

            case 3:     //Escala exponencial
                double exponente = double.Parse(
                    ((OperacionEscalaExponencial)(PanelConfiguracionOperacion.Children[0])).txtExponente.Text);
                señalResultante = Señal.escalaExponencial(señal, exponente);
                break;

            default:
                señalResultante = null;
                break;
            }
            //Elige entre la 1ra y la resultante
            double amplitudMaxima = (señal.AmplitudMaxima >= señalResultante.AmplitudMaxima) ?
                                    señal.AmplitudMaxima : señalResultante.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, tiempoFinal));
                }

                //Elige entre la mas grande de la 1ra y resultante y la segunda
                amplitudMaxima = (amplitudMaxima > segundaSeñal.AmplitudMaxima) ?
                                 amplitudMaxima : segundaSeñal.AmplitudMaxima;
            }

            foreach (Muestra muestra in señal.Muestras)
            {
                plnGrafica.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoInicial, amplitudMaxima));
            }

            if (CbOperacion.SelectedIndex != -1)
            {
                foreach (Muestra muestra in señalResultante.Muestras)
                {
                    plnGraficaResultante.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoInicial, amplitudMaxima));
                }
            }

            //original
            lblLimiteSuperior.Text = amplitudMaxima.ToString("F");
            lblLimiteInferior.Text = "-" + amplitudMaxima.ToString("F");

            //resultado
            lblLimiteInferiorResultante.Text = "-" + amplitudMaxima.ToString("F");
            lblLimiteSuperiorResultante.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));

            plnEjeY.Points.Clear();
            plnEjeY.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoInicial, amplitudMaxima));
            plnEjeY.Points.Add(adaptarCoordenadas(0.0, -amplitudMaxima, tiempoInicial, amplitudMaxima));

            //resultado
            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));
        }
Beispiel #10
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);

            Señal señal;

            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;

            default:
                señal = null;
                break;
            }

            //Establacer los valores que va usar la clase antes de que la llame.
            señal.TiempoInicial      = tiempoInicial;
            señal.TiempoFinal        = tiempoFinal;
            señal.FrecuenciaMuestreo = frecuenciaMuestreo;
            señal.construirSeñalDigital();

            plnGrafica.Points.Clear();



            //Escalar
            double factorEscala = double.Parse(txtfactorEscalaAmplitud.Text);

            if (checkboxEscalaAmplitud.IsChecked == true)
            {
                señal.escalar(factorEscala);
            }
            else if (checkboxEscalaAmplitud.IsChecked == false)
            {
                factorEscala = 1;
                señal.escalar(factorEscala);
            }

            //Desplazar
            double desplazamientoValor = double.Parse(txtDesplazamientoEnY.Text);

            if (checkboxDesplazamientoY.IsChecked == true)
            {
                señal.desplazar(desplazamientoValor);
            }
            else if (checkboxDesplazamientoY.IsChecked == false)
            {
                desplazamientoValor = 0;
                señal.desplazar(desplazamientoValor);
            }

            //Truncar
            if (checkboxUmbral.IsChecked == true)
            {
                double umbralValor = double.Parse(txtUmbral.Text);
                señal.truncar(umbralValor);
            }
            //Potencia
            if (checkboxPotencia.IsChecked == true)
            {
                double potenciaValor = double.Parse(txtPotencia.Text);
                señal.potencia(potenciaValor);
            }

            //Amplitud
            señal.actualizarAmplitudMaxima();



            if (señal != null)
            {
                //Recorrer una coleccion o arreglo, solo sirve cuando quieres recorrer todos los elementos.
                //Por cada iteracion se guardara un elemento conforme a la coleccion. (FOREACH)
                //Declarar la variable del tipo de dato que va recorrer
                foreach (Muestra muestra in señal.Muestras)
                {
                    plnGrafica.Points.Add(new Point((muestra.X - tiempoInicial) * scrContenedor.Width,
                                                    (muestra.Y / señal.AmplitudMaxima) * (((scrContenedor.Height / 2.0) - 30) * -1) + (scrContenedor.Height / 2))
                                          );
                }
            }


            //EJE X
            plnEjex.Points.Clear();
            //Punto de Principio
            plnEjex.Points.Add(new Point(0, (scrContenedor.Height / 2)));
            //Punto del fin
            plnEjex.Points.Add(new Point((tiempoFinal - tiempoInicial) * scrContenedor.Width, (scrContenedor.Height / 2)));
            //

            //EJE Y
            plnEjey.Points.Clear();
            //Punto de Principio
            plnEjey.Points.Add(new Point((0 - tiempoInicial) * scrContenedor.Width, señal.AmplitudMaxima * (((scrContenedor.Height / 2.0) - 30) * -1) + (scrContenedor.Height / 2)));
            //Punto del fin
            plnEjey.Points.Add(new Point((0 - tiempoInicial) * scrContenedor.Width, -señal.AmplitudMaxima * (((scrContenedor.Height / 2.0) - 30) * -1) + (scrContenedor.Height / 2)));
            //

            lblAmplitudMaximaY.Text         = señal.AmplitudMaxima.ToString();
            lblAmplitudMazimaNegativaY.Text = "-" + señal.AmplitudMaxima.ToString();
        }
        private void Graficar_Click(object sender, RoutedEventArgs e)
        {
            tiempoinicial      = double.Parse(txtTiempo_Inicial.Text);
            tiempofinal        = double.Parse(txtTiempo_Final.Text);
            frecuenciamuestreo = double.Parse(txtFrecuenciaMuestreo.Text);


            /*
             * senoidal = new SeñalSenoidal(amplitud, fase, frecuencia);
             */
            Señal señal;
            Señal señalResultante;
            Señal segundaseñal = null;

            switch (CbTipoSeñal.SelectedIndex)
            {
            case 0:     // Parabolica bolica
                señal = new SeñalParabolica();

                break;

            case 1:     //Senoidal
                amplitud   = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txtAmplitud.Text);
                fase       = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txtFase.Text);
                frecuencia = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion.Children[0])).txtFrecuencia.Text);
                señal      = new SeñalSenoidal(amplitud, fase, frecuencia);

                break;

            case 2:
                double alpha = double.Parse(((ConfiguracionSeñalExponencial)(panelConfiguracion.Children[0])).txtAlpha.Text);
                señal = new SeñalExponencial(alpha);
                break;

            case 3:
                string rutaArchivo = ((ControlAudio)(panelConfiguracion.Children[0])).txtRutaArchivo.Text;
                señal = new SeñalAudio(rutaArchivo);
                txtTiempo_Inicial.Text     = señal.TiempoInicial.ToString();
                txtTiempo_Final.Text       = señal.TiempoInicial.ToString();
                txtFrecuenciaMuestreo.Text = señal.FrecuenciaMuestreo.ToString();
                break;

            default:
                señal = null;
                break;
            }

            if (CbTipoSeñal.SelectedIndex != 3 && señal != null)
            {
                señal.TiempoInicial = tiempoinicial;

                señal.TiempoFinal = tiempofinal;

                señal.FrecuenciaMuestreo = frecuenciamuestreo;
            }


            señal.construirSeñal();


            /*
             * SeñalSigno signo = new SeñalSigno();
             */

            if (cbOperacion.SelectedIndex == 2)
            {
                switch (CbTipoSeñal_2.SelectedIndex)
                {
                case 0:     // Parabolica bolica
                    segundaseñal = new SeñalParabolica();

                    break;

                case 1:     //Senoidal
                    amplitud     = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion_2.Children[0])).txtAmplitud.Text);
                    fase         = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion_2.Children[0])).txtFase.Text);
                    frecuencia   = double.Parse(((ConfiguracionSeñalSenoidal)(panelConfiguracion_2.Children[0])).txtFrecuencia.Text);
                    segundaseñal = new SeñalSenoidal(amplitud, fase, frecuencia);

                    break;

                case 2:
                    double alpha = double.Parse(((ConfiguracionSeñalExponencial)(panelConfiguracion_2.Children[0])).txtAlpha.Text);
                    segundaseñal = new SeñalExponencial(alpha);
                    break;

                case 3:
                    string rutaArchivo = ((ControlAudio)(panelConfiguracion_2.Children[0])).txtRutaArchivo.Text;
                    segundaseñal               = new SeñalAudio(rutaArchivo);
                    txtTiempo_Inicial.Text     = segundaseñal.TiempoInicial.ToString();
                    txtTiempo_Final.Text       = segundaseñal.TiempoInicial.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 factorDesplaze = double.Parse(((OperacionDesplazamientoAmplitud)panelConfiguracionOperacion.Children[0]).txtDesplazamientoAmplitud.Text);
                señalResultante = Señal.desplazarAmplitud(señal, factorDesplaze);
                break;

            case 1:
                double factorEscala = double.Parse(((OperacionEscalaAmplitud)panelConfiguracionOperacion.Children[0]).txtFactorEscala.Text);
                señalResultante = Señal.escalarAmplitud(señal, factorEscala);
                break;

            case 2:
                señalResultante = Señal.multiplicarseñales(señal, segundaseñal);

                break;

            case 3:
                double factorExponencual = double.Parse(((OperacionEscalaExponencial)panelConfiguracionOperacion.Children[0]).txtFactorExponencial.Text);
                señalResultante = Señal.escalarExponencial(señal, factorExponencual);
                break;

            case 4:
                señalResultante = Señal.transformadaFourirer(señal);
                break;

            default:
                señalResultante = null;
                break;
            }


            //Elige entre la 1ra 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 , resultante y la segunda.
            if (cbOperacion.SelectedIndex == 2)
            {
                amplitudMaxima = (amplitudMaxima > segundaseñal.AmplitudMaxima) ? amplitudMaxima : segundaseñal.AmplitudMaxima;
            }

            plnGrafica.Points.Clear();
            plnGraficaResultante.Points.Clear();
            plnGrafica_2.Points.Clear();


            foreach (Muestra muestra1 in señal.Muestras)
            {
                plnGrafica.Points.Add(adaptarCoordenadas(muestra1.X, muestra1.Y, tiempoinicial, amplitudMaxima));
            }
            foreach (Muestra muestra in señalResultante.Muestras)
            {
                plnGraficaResultante.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoinicial, amplitudMaxima));
            }
            if (segundaseñal != null)
            {
                foreach (Muestra muestra in segundaseñal.Muestras)
                {
                    plnGrafica_2.Points.Add(adaptarCoordenadas(muestra.X, muestra.Y, tiempoinicial, amplitudMaxima));
                }
            }
            if (cbOperacion.SelectedIndex == 4)
            {
                int indicemaximo  = 0;
                int indiceinicial = (int)((690.0f * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                int indicefinal   = (int)((950.0f * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                for (int i = indiceinicial; i < indicefinal; i++)
                {
                    if (señalResultante.Muestras[i].Y > señalResultante.Muestras[indicemaximo].Y)
                    {
                        indicemaximo = i;
                    }
                }
                double frecuencia = (double)(indicemaximo * señalResultante.FrecuenciaMuestreo) / (double)señalResultante.Muestras.Count;
                lblHertz_Baja.Text = frecuencia.ToString("N") + "Hz";

                // Obtener la frecuencia alta
                int indicemaximoalta  = 0;
                int indiceinicialalta = (int)((1200.0 * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                int indicefinalalta   = (int)((1482.0 * (double)(señalResultante.Muestras.Count)) / señalResultante.FrecuenciaMuestreo);
                for (int i = indiceinicialalta; i < indicefinalalta; i++)
                {
                    if (señalResultante.Muestras[i].Y > señalResultante.Muestras[indicemaximoalta].Y)
                    {
                        indicemaximoalta = i;
                    }
                }
                double frecuenciaAlta = (double)(indicemaximoalta * señalResultante.FrecuenciaMuestreo) / (double)señalResultante.Muestras.Count;
                lblHertz_Baja.Text = frecuencia.ToString("N") + "Hz";
            }
            lblLimiteSuperior.Text = amplitudMaxima.ToString("F");
            lblLimiteInferior.Text = "-" + amplitudMaxima.ToString("F");

            lblLimiteInferiorResultado.Text = "-" + amplitudMaxima.ToString("F");
            lblLimiteSuperiorResultado.Text = amplitudMaxima.ToString("F");


            pnlEjeX.Points.Clear();
            pnlEjeX.Points.Add(adaptarCoordenadas(tiempoinicial, 0.0, tiempoinicial, amplitudMaxima));
            pnlEjeX.Points.Add(adaptarCoordenadas(tiempofinal, 0.0, tiempoinicial, amplitudMaxima));
            pnlEjeY.Points.Clear();
            pnlEjeY.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoinicial, amplitudMaxima));
            pnlEjeY.Points.Add(adaptarCoordenadas(0.0, -amplitudMaxima, tiempoinicial, amplitudMaxima));

            pnlEjeXResultante.Points.Clear();
            pnlEjeXResultante.Points.Add(adaptarCoordenadas(tiempoinicial, 0.0, tiempoinicial, amplitudMaxima));
            pnlEjeXResultante.Points.Add(adaptarCoordenadas(tiempofinal, 0.0, tiempoinicial, amplitudMaxima));

            pnlEjeYResultante.Points.Clear();
            pnlEjeYResultante.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoinicial, amplitudMaxima));
            pnlEjeYResultante.Points.Add(adaptarCoordenadas(0.0, amplitudMaxima, tiempoinicial, amplitudMaxima));
        }
        private void BotonGraficar_Click(object sender, RoutedEventArgs e)
        {
            double tiempoInicial      = double.Parse(txt_TiempoInicial.Text);
            double tiempoFinal        = double.Parse(txt_TiempoFinal.Text);
            double frecuenciaMuestreo = double.Parse(txt_FrecuenciaDeMuestreo.Text);

            Señal señal;

            switch (cb_TipoSeñal.SelectedIndex)
            {
            // Señal Senoidal
            case 0:
                double amplitud = double.Parse(
                    ((ConfiguracionSeñalSenoidal)
                     (panelConfiguracion.Children[0])).txt_Amplitud.Text

                    );
                double fase = double.Parse(
                    ((ConfiguracionSeñalSenoidal)
                     (panelConfiguracion.Children[0])).txt_Fase.Text

                    );
                double frecuencia = double.Parse(
                    ((ConfiguracionSeñalSenoidal)
                     (panelConfiguracion.Children[0])).txt_Frecuencia.Text

                    );

                señal = new SeñalSenoidal(5, 0, 8);
                break;

            // Señal Rampa
            case 1:
                señal = new SeñalRampa();
                break;

            case 2:

                double Alpha = double.Parse(
                    ((ConfiguracionSeñalExponencial)
                     (panelConfiguracion.Children[0])).txt_Alpha.Text

                    );
                señal = new SeñalExponencial(Alpha);
                break;

            // Señal xxxxx

            /* case 2:
             *  señal = new Señalyyyyy();
             *  break;
             */

            default:
                señal = null;
                break;
            }

            señal.TiempoInicial      = tiempoInicial;
            señal.TiempoFinal        = tiempoFinal;
            señal.FrecuenciaMuestreo = frecuenciaMuestreo;

            señal.construirSeñalDigital();

            plnGrafica.Points.Clear();

            if (señal != null)
            {
                // Sirve para recorrer una coleccion o arreglo
                foreach (Muestra muestra in señal.Muestras)
                {
                    plnGrafica.Points.Add(new Point((muestra.X - tiempoInicial) * scrContenedor.Width, (muestra.Y / señal.AmplitudMaxima * ((scrContenedor.Height / 2) - 30) * -1 + (scrContenedor.Height / 2))));
                }

                lbl_AmplitudMaxima.Text = señal.AmplitudMaxima.ToString();
                lbl_AmplitudMinima.Text = "-" + señal.AmplitudMaxima.ToString();
            }

            // Línea del Eje X
            plnEjeX.Points.Clear();
            plnEjeX.Points.Add(new Point(0, scrContenedor.Height / 2));
            plnEjeX.Points.Add(new Point((tiempoFinal - tiempoInicial) * scrContenedor.Width, scrContenedor.Height / 2));

            // Línea del Eje Y
            plnEjeY.Points.Clear();
            plnEjeY.Points.Add(new Point((-tiempoInicial) * scrContenedor.Width, 0));
            plnEjeY.Points.Add(new Point((-tiempoInicial) * scrContenedor.Width, scrContenedor.Height));
        }
Beispiel #13
0
        private void graficar_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;

            switch (cbTipoSeñal.SelectedIndex)
            {
            //Seniodal
            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 Rampa();
                break;

            // Exponencial
            case 2:
                double alpha = double.Parse(((ConfiguracionSeñalExponencial)panelConfiguracion.Children[0]).txtAlpha.Text);
                señal = new SeñalExponencial(alpha);
                break;

            // Exponencial2
            case 3:
                double alpha2 = double.Parse(((ConfiguracionSeñalExponencial2)panelConfiguracion.Children[0]).txtAlpha2.Text);
                señal = new SeñalExponencial2(alpha2);
                break;

            // Exponente
            case 4:
                double exponente = double.Parse(((ConfiguracionSeñalExponencial2)panelConfiguracion.Children[0]).txtExponente.Text);
                señal = new SeñalExponencial2(exponente);
                break;

            default:
                señal = null;
                break;
            }



            plnGrafica.Points.Clear();

            if (señal != null)
            {
                señal.tiempoFinal        = tiempoFinal;
                señal.tiempoInicial      = tiempoInicial;
                señal.frecuenciaMuestreo = frecuenciaMuestreo;

                //contruir señal
                señal.construirSeñalDigital();

                //escalar
                if ((bool)chbEscalar.IsChecked)
                {
                    double escalar = double.Parse(txtEscalar.Text);
                    señal.escalar(escalar);
                }

                //desplazamiento
                if ((bool)chbDesplazamiento.IsChecked)
                {
                    double desplazamiento = double.Parse(txtDesplazamientoY.Text);
                    señal.desplazarY(desplazamiento);
                }

                //desplazamiento
                if ((bool)chbTruncar.IsChecked)
                {
                    double umbral = double.Parse(txtUmbral.Text);
                    señal.truncar(umbral);
                }



                //actualizar amplitud maxima
                señal.actualizarAmplitudMaxima();

                //recorrer una coleccion o arreglo
                foreach (Muestra muestra in señal.muestras)
                {
                    plnGrafica.Points.Add(new Point((muestra.x - tiempoInicial) * scrContenedor.Width, (muestra.y / señal.amplitudMaxima * ((scrContenedor.Height / 2.0) - 30) * -1) + (scrContenedor.Height / 2)));
                }

                lblAmplitudMaximaY.Text         = señal.amplitudMaxima.ToString();
                lblAmplitudMaximaNegativaY.Text = "-" + señal.amplitudMaxima.ToString();
            }



            plnEjeX.Points.Clear();
            //punto del principio
            plnEjeX.Points.Add(new Point(0, scrContenedor.Height / 2));
            //punto del fin
            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, (1 * ((scrContenedor.Height / 2.0) - 30) * -1) + (scrContenedor.Height / 2)));
            //punto del fin
            plnEjeY.Points.Add(new Point((0 - tiempoInicial) * scrContenedor.Width, (-1 * ((scrContenedor.Height / 2.0) - 30) * -1) + (scrContenedor.Height / 2)));
        }