procesamientosenhal.java

This is a example about programming a neural network

/*
 * ProcesamientoSenhal.java
 *
 * Created on 17 de enero de 2008, 12:56 AM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package rah;

/**
 *
 * @author JhonFranko
 */
import java.awt.*;
import java.util.*;

public class ProcesamientoSenhal
{
    
    /** Creates a new instance of ProcesamientoSenhal */
    private double[] datosVoz;
    private double[] newDatosVoz=null;    
    private int ancho;
    private fft senhal;
    private double[][] vAux;
    private double[][] vFactor; 
    
    public ProcesamientoSenhal(double[] dxVoz,int ancho)
    {
        this.datosVoz=dxVoz;
        this.ancho=ancho;
        
    }
    public double promedio(double[] x,int n,int inicio,int razon)
    {
       double p=0;
       int cont=inicio;
       
      for(int i=0;i<n;i++)
      {
         if(cont<x.length && cont>0)   
         {
          p=p+Math.abs(x[cont]);           
          cont=cont+razon;

        } 
      }      
       p=p/(double)n;
       return p;
    }
   public double obtener_Umbral(double[] x,int r,int n)
    {
      double umbral=0;
      double ValorI=0,ValorF=0;
      int cont=n;
      int c=0;
      
      ValorI=0;
      for(int i=0;i<r;i++)
      {
         ValorI=ValorI+ Math.abs(x[c]);
         c=c+cont;
      }
      ValorI=ValorI/(double)r;
      ValorF=0;
      c=cont;
      for(int i=0;i<r;i++)
      {
         ValorF=ValorF+ Math.abs(x[x.length-c]);
         c=c+cont;         
      }      
      
      ValorF=ValorF/(double)r;      
      umbral=((ValorI+ValorF)/2.0)+n;
              
      return umbral;    
    }

    public double[] Sel_Elim_Seg_Inservibles(int radio,int n)
    {

          int umbral=(int)obtener_Umbral(datosVoz,radio,n);          
          System.out.println("UMBRAL 1"+umbral);          
         
          
          int Inicio=0,Fin=0;
          int cont=2;
          for(int i=n;i<datosVoz.length-n;i=i+n)
          {
              if((int)promedio(datosVoz,cont,i,-n)>umbral)
              {
                  System.out.println("PROMEDIO 1 "+promedio(datosVoz,cont,i,-n));
                 Inicio=i;
                 i=datosVoz.length;
              }
              cont++;
          }  
          cont=2;
          for(int i=datosVoz.length-(n+2);i>0;i=i-n)
          {
              if((int)promedio(datosVoz,cont,i,n)>umbral)
              {
                  System.out.println("PROMEDIO 2 "+promedio(datosVoz,cont,i,n));                  
                 Fin=i;
                 i=0;
              }
              cont++;              
          }         
          //-------------------------------------------
          //Llenado de datos de nuevo vector
           System.out.println("Inicio "+Inicio+ " Fin "+ Fin);
          int t=(Fin-Inicio)+1;
          newDatosVoz=new double[t];           
          int c=0;
          for(int i=Inicio;i<=Fin;i++)
          {
              newDatosVoz[c]=datosVoz[i];
              c++;
          }  
          System.out.println("Nuevos Datos "+newDatosVoz.length);
          return newDatosVoz;
    }
    
     public void setDxVoz(double[] dxVoz)
    {
        this.datosVoz=dxVoz;
    }    
    
//******************************************************************************************
// Operaciones estadisticas     

    public static double media(double arr[ ])
    {
        double sum = 0.0;

        for(int i = 0; i < arr.length ; i++)
        {
            sum += arr[i];
        }

        return sum / arr.length;
    }    
    
    public static double varianza(double arr[ ], double media)
    {
        double sum = 0.0;

        for(int i = 0; i < arr.length ; i++)
        {
            sum += Math.pow(arr[i] - media, 2);
        }
        
        return sum / (arr.length - 1);
    }
//******************************************************************************************    
     public double[] rescatarPicos(double[] x, double umbral){
         
         double[] xa=new double[x.length];
         double[] xb=new double[x.length];
         double[] xc=new double[x.length];
         
         for(int i=0;i<x.length;i++){
             
             xa[i]=Math.abs(x[i]);
             
             if(xa[i] > umbral){
                 
                 xb[i]=1.0;
             }
             else{
                 
                 xb[i]=0.0;
             }             
             xc[i]= xb[i] * (xa[i] - umbral);
          }  
         return xc;
     }
     
     public double[] cuboPicos(double[] x){
         
         double[] xa=new double[x.length];         
         double[] xc=new double[x.length];
         
         for(int i=0;i<x.length;i++){
             
             xa[i]=2 * x[i];
             xc[i]= Math.pow(xa[i],3);
          }  
         return xc;
     }
     
     public double[][] obtPicos(double[] x){
         
         double[][] localMagnitud=new double[x.length][2];
         int j=0;
         
         for(int i=2;i<x.length-1;i++){
             
             if( x[i]>=x[i-1]  && x[i]>=x[i+1]  &&  x[i]!=x[i+1]){
             
                localMagnitud[j][0]=i;
                localMagnitud[j][1]=x[i];
                j++;
             }    
          }  
         
         double[][] localAux=new double[j][2];
         
         for(int i=0; i<j; i++){
             
             localAux[i][0]=localMagnitud[i][0];
             localAux[i][1]=localMagnitud[i][1];
         }
         
         return localAux;
     }
     
    public double[] convolucion(double [] A,double [] B){
        
	   int t=A.length+B.length-1;	   	
	   double[] c=new double[t];		
				
			for(int i=0; i<A.length; i++)
			{
			    for(int j=0; j<B.length; j++)
			    {
			    	c[i+j] += A[i]*B[j];
			    }	
			}	
            return c;
     }
        
    public double maximo(double[]x){
        
        double max=0.0;
        
        max=x[0];
        
        for(int j=1; j<x.length; j++){
            
            if(x[j]>max){
                
                max=x[j];
            }
        }	
        return max;
    }
    public double[] actualizarVectorDistancias(double[] d)
    {

       double[] dTemp=new double[d.length];
       int j=0;
       
         for(int i=0;i<d.length;i++){                        
             if(d[i]> 0)       
             {
                 dTemp[j]=d[i];             
                 j++;             
             }
         }
       double[] daux=new double[j];
       
         for(int i=0;i<j;i++){                       
                 daux[i]=dTemp[i];             
         }       
       return daux;
    }    
    
     public double obtencionPitch(){
         
         // DATOS DE ENTRADA FUNDAMENTAL
         double[] x=datosVoz;
         double fs=datosVoz.length;
         
         
         double p=0.0, umbral=0.0;
         double[] xc1=new double[x.length];         
         double[] xc2=new double[x.length];         

         xc1=cuboPicos(x);
         umbral=maximo(xc1) * 0.4;
         xc2=rescatarPicos(xc1,umbral);
         
         double[] mediaP={0.05,0.1,0.2,0.3,0.2,0.1,0.05};

         double[] mSuavisado=null; 
         double[][] localMagnitud=null;

         mSuavisado=convolucion(xc2,mediaP);
         localMagnitud=obtPicos(mSuavisado);
         double[] d=new double[localMagnitud.length];            
         
       //Calculo las distancias entre cada par de picos sucesivos  
         for (int i = 0;i<localMagnitud.length-1;i++ )                          
             d[i] = localMagnitud[i+1][0] - localMagnitud[i][0];
        
        //Obtengo el promedio y la desviacion estandar
        double dm = media(d);            
        double ds = Math.sqrt(varianza(d,dm));         
        
        //Desechamos aquellos datos que entre la distancia conrrespecto a su media sean mayores
        //a la desviacion standar
        
         double[] check=new double[d.length];
         double[] dnew=new double[d.length];
         
         for(int i=0;i<d.length;i++){             
             if(Math.abs(d[i]-dm)< ds)                 
                 check[i]=1.0;             
             else                 
                 check[i]=0.0;             
         }
        // Recalculando las distancias entre picos con respecto a aquellos
         // que han sido removidos
         for(int i=0;i<check.length-1;i++){        

            if(check[i]==0 && d[i]<dm)
            {         
              d[i+1]=d[i]+d[i+1];
              i++;
            } 
            else{
               if(check[i]==0 )
               {
                 dnew[i]=Math.round(0.5*d[i]);
               }
               else
               {
                 dnew[i]=d[i];
               }
            }             
         }              
        // El vector de nuevas distancias sera todo a quel que sea mayor que cero
          
          double[] dnew2=null;
         
         dnew2=actualizarVectorDistancias(dnew);
         
         double pitchPeriod=media(dnew2);
         
         p=fs/pitchPeriod;
         
         return p;
     }
 //***************************************************************************************    
 //---------------------------------------------------------------------------------------
 //---------------------------------------------------------------------------------------
 // Tranformada de Fourier
    public double[] obtenerFFT(double[] DxVoz)
    {
      double[] vFFT=null;
      senhal= new fft(DxVoz);
      
            senhal.validarVector();
            vAux=senhal.getVectorValido();
            //senhal.mostrarVector(vAux);
            senhal.fftDiezmado();
            vAux=senhal.getVectorValido();
            //senhal.mostrarVector(vAux);
            senhal.ordenarVector(vAux);
            vFFT=senhal.obtenerVectorSalida();      
      
      return vFFT;    
    }
     
     
     
 // ALGORITMOS DE PROC DIGITAL DEL HABLA
   public double[] filtro_PreEnfasis(double[] dxVoz,double alfa)
   {
     double[] y=new double[dxVoz.length];
             
           y[0]=dxVoz[0];
           
            for(int i=0;i<dxVoz.length-2;i++)
            {
              y[i+1]=dxVoz[i+1]-(alfa*dxVoz[i]);
            }         
      
     return y;
   }
     
   //**************************************************************************************
   // Transformada Corta de Fourier
    public double[] ventanamiento(double[] ventana,double factorAlfa)
    {
          for(int i=0;i<ventana.length;i++)
          {
              int m=ventana.length;
              //hanning o hamming
              ventana[i]=ventana[i]*((1-factorAlfa)-(factorAlfa*(Math.cos((2*Math.PI*(m-i))/m))));
              
          }
      
      return ventana;
    }
    public double[] obtenerTFCF(double[] dxVoz,int longVent,int desp)
    {
      double[] vTFCF=new double[dxVoz.length];
      int i,j,contTFCF=0;
      for (i=0;i<dxVoz.length-(desp+longVent);i+=desp)
      {
          //Obtengo ventana
          double[] ventana=new double[longVent];
          int k=0;
          for(j=i;j<i+longVent;j++)
          {
              ventana[k]=dxVoz[j];
              k++;
          }
          //Calculo FFT de la ventana
          double[] ventana2=ventanamiento(ventana,0.46);
          double[] FFT_Vent=obtenerFFT(ventana2); 
       
          //Utilizo solo la mitad del vector  FFT_Vent         
          int c=contTFCF;
          k=0;
          for(j=c;j<c+longVent/2;j++)
          {
              vTFCF[j]=FFT_Vent[k];
              //System.out.println("Vector TFCF en "+j+"= "+vTFCF[j]);
              k++;
          }          
          contTFCF+=longVent/2;
      }      
      
      return vTFCF;    
    }
}