Estoy trabajando con el proyecto android.Necesito algoritmo de la FFT para el proceso de android los datos del acelerómetro.Hay FFT de la biblioteca disponible en el sdk de android?

6 Comentarios

  1. 40

    Puede utilizar esta clase, que es lo suficientemente rápido como para audio en tiempo real análisis de

    public class FFT {
    int n, m;
    //Lookup tables. Only need to recompute when size of FFT changes.
    double[] cos;
    double[] sin;
    public FFT(int n) {
    this.n = n;
    this.m = (int) (Math.log(n) / Math.log(2));
    //Make sure n is a power of 2
    if (n != (1 << m))
    throw new RuntimeException("FFT length must be power of 2");
    //precompute tables
    cos = new double[n / 2];
    sin = new double[n / 2];
    for (int i = 0; i < n / 2; i++) {
    cos[i] = Math.cos(-2 * Math.PI * i / n);
    sin[i] = Math.sin(-2 * Math.PI * i / n);
    }
    }
    public void fft(double[] x, double[] y) {
    int i, j, k, n1, n2, a;
    double c, s, t1, t2;
    //Bit-reverse
    j = 0;
    n2 = n / 2;
    for (i = 1; i < n - 1; i++) {
    n1 = n2;
    while (j >= n1) {
    j = j - n1;
    n1 = n1 / 2;
    }
    j = j + n1;
    if (i < j) {
    t1 = x[i];
    x[i] = x[j];
    x[j] = t1;
    t1 = y[i];
    y[i] = y[j];
    y[j] = t1;
    }
    }
    //FFT
    n1 = 0;
    n2 = 1;
    for (i = 0; i < m; i++) {
    n1 = n2;
    n2 = n2 + n2;
    a = 0;
    for (j = 0; j < n1; j++) {
    c = cos[a];
    s = sin[a];
    a += 1 << (m - i - 1);
    for (k = j; k < n; k = k + n2) {
    t1 = c * x[k + n1] - s * y[k + n1];
    t2 = s * x[k + n1] + c * y[k + n1];
    x[k + n1] = x[k] - t1;
    y[k + n1] = y[k] - t2;
    x[k] = x[k] + t1;
    y[k] = y[k] + t2;
    }
    }
    }
    }
    }

    Advertencia: este código parece ser derivado de aquí, y tiene una licencia GPLv2.

    • Se puede saber que el algoritmo está implementado en el código anterior? Funciona muy bien, pero tengo curiosidad por entender que en el algoritmo de nivel. Gracias
    • href=»https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm» >en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm
    • puede ser usado para los datos del EEG así?
    • puede ejecutar fft en tiempo real con ventana de 8192 muestras?
    • ¿Qué son los parámetros x e y a la función fft? Entiendo que la entrada de muestras debe ir en la x de la matriz, pero ¿cuál es el propósito de y?
    • se parece a el y matriz de tabla de salida.
    • cómo utilizar este algoritmo?
    • Esto parece bastante prometedor, pero aún así, ¿cuál es el parámetro y? Es la tabla de ondas ?
    • Parece que estamos teniendo aquí un icono de «cómo no escribir código» ejemplo. Uno de los caracteres variables, inútil comentarios, absolutamente nada de explicaciones sobre lo que realmente está sucediendo.
    • Como una nota al margen (mi supuestos de variación de adivinar-ness), x e y son las matrices con los datos de entrada (matriz de pasado x coordinares de acelerómetro y una matriz de y correspondiente queridos). Las matrices se cambian de lugar para hacer copias. ¿Cuál es la salida – no lo sé. Mi conjetura sería que 512 (por ejemplo) de entrada dobles son transformados en 256 complejo (amplitud, fase) números. Pero eso es una conjetura.
    • Dónde está ese código? La puedo utilizar sin licencia?
    • Parece ser de aquí, ee.columbia.edu/~ronw/código/MEAPsoft/doc/html/…
    • Para aquellos que buscan usar este.
    • Finalmente responde a lo que la matriz y significa: es la parte imaginaria de los complejos de entrada a una FFT. En el caso de bienes numerada de entrada de la matriz y se rellena con 0 antes de cada llamada de fft(). Y también una nota final sobre la concesión de licencias: Este código es casi idéntico a la implementación estándar de la Cooley/Tukey algoritmo a partir de mediados de la década de 1960 (por ejemplo, publicado en el «Numérico Recetas en C» como four1.c).
    • Véase Francisco de respuesta por debajo de un gran explicación

  2. 11

    Uso de la clase a: https://www.ee.columbia.edu/~ronw/code/MEAPsoft/doc/html/FFT_8java-source.html

    Breve explicación: llame fft() proporcionar x como datos de amplitud, y como todos los ceros de la matriz, después de la función, que devuelve la primera respuesta será un[0]=x[0]^2+y[0]^2.

    Explicación completa: FFT es compleja transformación se lleva a N números complejos y produce N números complejos. De modo que x[0] es la parte real del primer número, y[0] es la parte compleja. Esta función calcula en el lugar, por lo que cuando se devuelve la función de x y de y se tiene la real y piezas complejas de la transformación.

    Un uso típico es para calcular el espectro de potencia de audio. Su muestras de audio sólo tienen parte real, que su parte compleja es 0. Para calcular el espectro de potencia de agregar la plaza de la real y complejo de partes P[0]=x[0]^2+y[0]^2.

    También es importante tener en cuenta que la transformada de Fourier, cuando se aplica sobre los números reales, como resultado simétrico resultado (x[0]==x[x.lenth-1]). Los datos en x[x.longitud/2] los datos de la frecuencia f=0 hz. x[0]==x[x.longitud-1] tiene los datos para una frecuencia equivale a tener la tasa de muestreo (por ejemplo, si el muestreo fue 44000Hz que significa que f[0] refeers a 22kHz).

    Procedimiento completo:

    1. crear la matriz p[n] con 512 muestras con ceros
    2. Recoger 1024 muestras de audio, escribir en x
    3. Conjunto y[n]=0 para todo n
    4. calcular la fft(x,y)
    5. calcular p[n]+=x[n+512]^2+y[n+512]^2 para todo n=0 a 512
    6. ir de 2 a tomar otro lote (después de los 50 lotes de ir al siguiente paso)
    7. la parcela p
    8. ir a 1

    De ajustar el número fijo para su gusto.

    El número 512 define el muestreo de la ventana, no voy a explicarlo. Sólo evitar la reducción de mucho.

    El número 1024 debe ser siempre el doble de la del último número.

    El número 50 define tasa de actualización. Si la frecuencia de muestreo es de 44000 muestras por segundo que la actualización de la tasa será: R=44000/1024/50 = 0.85 segundos.

  3. 7

    kissfft es un bastante decente de la biblioteca que se compila en android. Tiene una forma más versátil de la licencia de FFTW (aunque FFTW es bastante mejor).

    Usted puede encontrar un android de unión para kissfft en libgdx https://github.com/libgdx/libgdx/blob/0.9.9/extensions/gdx-audio/src/com/badlogic/gdx/audio/analysis/KissFFT.java

    O si desea una solución basada en Java puro intentar jTransforms
    https://sites.google.com/site/piotrwendykier/software/jtransforms

  4. 4

    Utilizar este clase (el que EricLarch la respuesta se deriva de).

    Notas De Uso

    Esta función sustituye a la entradas de las matrices con la salida de la FFT.

    De entrada

    • N = el número de puntos de datos (el tamaño de la matriz de entrada, debe ser una potencia de 2)
    • X = la parte real de sus datos para ser transformado
    • Y = la parte imaginaria de los datos a ser transformado

    es decir, si su entrada es
    (1+8i, 2+3j, 7-i-10-3i)

    • N = 4
    • X = (1, 2, 7, -10)
    • Y = (8, 3, -1, -3)

    Salida

    • X = la parte real de la FFT de salida
    • Y = la parte imaginaria de la FFT de salida

    Para obtener su clásico gráfico FFT, se desea calcular la magnitud de las partes real e imaginaria.

    Algo como:

    public double[] fftCalculator(double[] re, double[] im) {
    if (re.length != im.length) return null;
    FFT fft = new FFT(re.length);
    fft.fft(re, im);
    double[] fftMag = new double[re.length];
    for (int i = 0; i < re.length; i++) {
    fftMag[i] = Math.pow(re[i], 2) + Math.pow(im[i], 2);
    }
    return fftMag;
    }

    Ver también esta respuesta de StackOverflow para obtener las frecuencias, si el original de la entrada fue de magnitud vs tiempo.

  5. 1

    @Wang J
    A su salida de la magnitud parece mejor que la respuesta dada en el hilo se han vinculado, sin embargo, que es todavía la magnitud al cuadrado … la magnitud de un número complejo

    z = a + ib

    se calcula como

    |z|=sqrt(a^2+b^2)

    la respuesta en los enlaces de hilo sugiere que, para la pura entradas reales de las salidas
    debe ser el uso de un2 o un para la salida, ya que los valores de

    a_(i+N/2) = -a_(i),

    con b_(i) = a_(i+N/2) significado la parte compleja en su mesa se encuentra en el segundo
    la mitad de la tabla de salida.

    yo.e la segunda mitad de la tabla de salida para una entrada de la tabla de reales es el conjugado de la real …

    así z = a-ia dando una magnitud

    |z|=sqrt(2a^2) = sqrt(2)a

    así que vale la pena señalar los factores de escalado …
    Yo recomendaría mirar, todo esto en un libro o en el wiki para estar seguro.

  6. 1

    Sí, no es el JTransforms que se mantiene en github aquí y disponible como un Maven plugin aquí.

    Utilizar con:

    compile group: 'com.github.wendykierp', name: 'JTransforms', version: '3.1'

    Pero con las más recientes, Gradle versiones necesita usar algo como:

    dependencies {
    ... 
    implementation 'com.github.wendykierp:JTransforms:3.1'
    }

Dejar respuesta

Please enter your comment!
Please enter your name here