Confronta valori o struttura del grafico

Question

Ho un'applicazione Android che sta ricevendo le coordinate del gesto (3 assi - x, y, z). Ho bisogno di confrontarli con le coordinate che ho nel mio DB e determinare se sono uguali o meno.

Ho anche bisogno di aggiungere un po 'di tolleranza, dal momento che l'accelerometro (dispositivo che cattura i gesti) è molto sensibile. Sarebbe facile, ma voglio anche prendere in considerazione per es. "grande cerchio" disegnato nell'aria, identico a "piccolo cerchio" disegnato nell'aria. il che significa che ci sarebbero valori diversi, ma la struttura del grafico sarebbe la stessa, giusto?

Ho sentito parlare della traduzione dei valori dei grafici in bit e quindi del confronto. È l'approccio giusto? Esiste una libreria per tale confronto?

Finora l'ho appena codificato, coprendo tutte le mie esigenze tranne l'ultima (grande cerchio o piccola cerchia).

Il mio codice ora:

private int checkWhetherGestureMatches(byte[] values, String[] refValues) throws IOException { 
     int valuesSize = 32; 
     int ignorePositions = 4; 

     byte[] valuesX = new byte[valuesSize]; 
     byte[] valuesY = new byte[valuesSize]; 
     byte[] valuesZ = new byte[valuesSize]; 

     for (int i = 0; i < valuesSize; i++) { 
      int position = i * 3 + ignorePositions; 
      valuesX[i] = values[position]; 
      valuesY[i] = values[position + 1]; 
      valuesZ[i] = values[position + 2]; 
     } 


     Double[] valuesXprevious = new Double[valuesSize]; 
     Double[] valuesYprevious = new Double[valuesSize]; 
     Double[] valuesZprevious = new Double[valuesSize]; 


     for (int i = 0; i < valuesSize; i++) { 
      int position = i * 3 + ignorePositions; 
      valuesXprevious[i] = Double.parseDouble(refValues[position]); 
      valuesYprevious[i] = Double.parseDouble(refValues[position + 1]); 
      valuesZprevious[i] = Double.parseDouble(refValues[position + 2]); 
     } 


     int incorrectPoints = 0; 
     for (int j = 0; j < valuesSize; j++) { 
      if (valuesX[j] < valuesXprevious[j] + 20 && valuesX[j] > valuesXprevious[j] - 20 
        && valuesY[j] < valuesYprevious[j] + 20 && valuesY[j] > valuesYprevious[j] - 20 
        && valuesZ[j] < valuesZprevious[j] + 20 && valuesZ[j] > valuesZprevious[j] - 20) { 
      } else { 
       incorrectPoints++; 
      } 
     } 
     return incorrectPoints; 
    } 

EDIT:

ho trovato JGraphT, potrebbe funzionare. Se ne sai già qualcosa, fammi sapere.

EDIT2:

vedere queste immagini, che sono lo stesso gesto, ma uno è fatto in un movimento più lento rispetto ad un altro.

veloce uno:

più lenta: le immagini

non ho catturato dello stesso gesto in cui si potrebbe essere più piccolo di un altro, potrebbe aggiungere che più tardi.

Answer 1

Ho utilizzato un'implementazione Java dell'algoritmo Dynamic Time Wrapping. La libreria si chiama fastDTW.

Sfortunatamente da quello che sottovaluto non lo supportano più, anche se ho trovato un uso per questo. https://code.google.com/p/fastdtw/

non ricordo ora, ma penso che ho usato questo e compilato da solo: https://github.com/cscotta/fastdtw/tree/master/src/main/java/com/fastdtw/dtw

Answer 2

Se l'elenco dei gesti è complesso, suggerirei di addestrare una rete neurale in grado di classificare i gesti in base ai bit del valore del grafico che hai menzionato. Il compito è molto simile alla classificazione delle cifre numeriche scritte a mano, per cui molte risorse ci sono in rete.

L'altro approccio sarebbe quello di indovinare matematicamente la forma del gesto, ma dubito che sarà utile considerando la tolleranza dell'accelerometro e il fatto che gli utenti non disegnino forme precise.

Answer 3

(a) convertire le coordinate 3D in una figura in 2D semplice. Utilizzare matrix transformations.

(b) normalizzare la bilancia gesto - nuovo con trasformazioni di matrice

(c) normalizzare il numero di punti o utilizzare interpolazione nel passaggio successivo.

(d) calcolare la differenza tra la stored (s) gesto e corrente (c) gesto come

Sum((Xs[i] - Xc[i])^2 + (Ys[i] - Yc[i])^2) where i = 0 .. num of points 

Se la differenza è inferiore a vostra precisione predefinito - gesti sono uguali.