Rilevamento e correzione di valori anomali in una traiettoria GPS

Ho bisogno di trovare un algoritmo o un metodo in grado di rilevare i latitude longitude punti anomali in una traiettoria durante la post-elaborazione , che può quindi essere risolto (riportato nel percorso della traiettoria in base ai suoi vicini).

Come esempio del tipo di punti anomali che vorrei rilevare e correggere, ho allegato un'immagine che dimostra:

Ho provato a usare un filtro Kalman inodore per appianare i dati nel miglior modo possibile, ma questo non sembra funzionare abbastanza efficacemente per valori anomali più estremi (dati grezzi in blu, dati levigati in rosso):

Il mio UKF potrebbe non essere calibrato correttamente (ma sono abbastanza sicuro che lo sia).

Le traiettorie sono quelle di deambulatori, corridori, ciclisti: movimento a propulsione umana che può iniziare e fermarsi, ma non cambiare drasticamente la velocità o la posizione in modo rapido o improvviso.

Una soluzione che non si basa su dati di temporizzazione (e solo su dati di posizione) sarebbe estremamente utile (poiché i dati elaborati potrebbero non contenere sempre dati di temporizzazione). Tuttavia, sono consapevole di quanto improbabile esista questo tipo di soluzione, quindi sono altrettanto felice di avere qualsiasi soluzione!

Idealmente, la soluzione rileverà il valore anomalo in modo da poterlo correggere, risultando in una traiettoria corretta:

Risorse che ho setacciato:

• Smooth GPS data- /programming/1134579/smooth-gps-data

• Common GPS and Geospatial Tracking Challenges and Solutions- http://www.toptal.com/gis/adventures-in-gps-track-analytics-a-geospatial-primer (la soluzione sembra perdere la precisione dei dati)

• Quale algoritmo dovrei usare per rimuovere valori anomali nei dati di traccia?

Come parte di uno strumento per l'elaborazione delle reti fluviali, ho creato uno strumento di controllo della qualità per cercare "picchi" nella rete. Mentre non sto suggerendo di usare il mio strumento (come è per l'elaborazione delle reti fluviali), vi rimando al file Help che mostra un'immagine di ciò che avevo fatto.

Avevo sviluppato il codice usando la legge dei coseni per identificare gli angoli successivi tra ogni segmento di linea di una polilinea. Potresti sviluppare il tuo codice attorno a questa idea per fare un passo lungo una polilinea e identificare angoli estremi.

Algoritmo che uso.

1. Calcola l'albero dei punti minimo euclideo:

2. Trova 2 punti più distanti tra loro su questa rete

3. Trova il percorso più breve tra loro:

Come si può vedere, si potrebbe tagliare l'angolo in una curva a gomito.

Ho l'implementazione di ArcGIS python dell'algoritmo sopra, usa il modulo networkx. Fammi sapere se questo è interessante e aggiornerò la mia risposta con lo script

AGGIORNARE:

# Connects points to make polyline. Makes 1 line at a time
# Tool assumes that 1st layer in Table of Conternt is TARGET polyline feature class,
# second layer in TOC is SOURCE point fc.
# If no selection found in SOURCE layer, works on entire dataset

import arcpy, traceback, os, sys
import itertools as itt
from math import sqrt
sys.path.append(r'C:\Users\felix_pertziger\AppData\Roaming\Python\Python27\site-packages')
import networkx as nx
from networkx import dijkstra_path_length

try:
    def showPyMessage():
        arcpy.AddMessage(str(time.ctime()) + " - " + message)
    def CheckLayerLine(infc):
        d=arcpy.Describe(infc)
        theType=d.shapeType
        if theType!="Polyline":
            arcpy.AddWarning("\nTool designed to work with polylines as TARGET!")
            raise NameError, "Wrong input\n"
        return d
    def CheckLayerPoint(infc):
        d=arcpy.Describe(infc)
        theType=d.shapeType
        if theType!="Point":
            arcpy.AddWarning("\nTool designed to work with points as SOURCE!")
            raise NameError, "Wrong input\n"
        return d
    mxd = arcpy.mapping.MapDocument("CURRENT")
    layers = arcpy.mapping.ListLayers(mxd)
    if len(layers)<=1:
        arcpy.AddWarning("\nNot enough layers in the view!")
        raise NameError, "Wrong input\n"
    destLR, sourceLR=layers[0],layers[1]
    a = CheckLayerPoint(sourceLR);d = CheckLayerLine(destLR)

#  copy all points to manageable list
    g=arcpy.Geometry()
    geometryList=arcpy.CopyFeatures_management(sourceLR,g)
    nPoints=len(geometryList)
    arcpy.AddMessage('Computing minimum spanning tree')
    list2connect=[p.firstPoint for p in geometryList]
#  create network    
    p=list(itt.combinations(range(nPoints), 2))
    arcpy.SetProgressor("step", "", 0, len(p),1)
    G=nx.Graph()
    for f,t in p:
        p1=list2connect[f]
        p2=list2connect[t]
        dX=p2.X-p1.X;dY=p2.Y-p1.Y
        lenV=sqrt(dX*dX+dY*dY)
        G.add_edge(f,t,weight=lenV)
        arcpy.SetProgressorPosition()
    arcpy.AddMessage(len(G.edges()))
    mst=nx.minimum_spanning_tree(G)
    del G

#  find remotest pair
    arcpy.AddMessage(len(mst.edges()))
    length0=nx.all_pairs_dijkstra_path_length(mst)
    lMax=0
    for f,t in p:
        lCur=length0[f][t]
        if lCur>lMax:
            lMax=lCur
            best=(f,t)
    gL=nx.dijkstra_path(mst,best[0],best[1])
    del mst
    nPoints=len(gL)
    ordArray=arcpy.Array()
    for i in gL: ordArray.add(list2connect[i])

#  append line to TARGET
    curT = arcpy.da.InsertCursor(destLR,"SHAPE@")
    curT.insertRow((arcpy.Polyline(ordArray),))
    arcpy.RefreshActiveView()
    del curT

except:
    message = "\n*** PYTHON ERRORS *** "; showPyMessage()
    message = "Python Traceback Info: " + traceback.format_tb(sys.exc_info()[2])[0]; showPyMessage()
    message = "Python Error Info: " +  str(sys.exc_type)+ ": " + str(sys.exc_value) + "\n"; showPyMessage()            

Un'idea è quella di creare uno script che elenca gli angoli (e forse anche la lunghezza) di ogni segmento del tuo percorso. Ora puoi confrontare i valori di ogni segmento con i suoi vicini diretti (e possibilmente anche i secondi vicini per aumentare la precisione) e selezionare tutti quei punti in cui i valori superano un dato valore di soglia. Infine, elimina semplicemente i punti dal tuo percorso.

Vale anche la pena guardare il metodo Median-5.

Ciascuna coordinata x (o y) è impostata sulla mediana dei 5 valori x (o y) attorno ad essa in sequenza (cioè se stessa, i due valori precedenti e i due valori successivi).

ad es. x3 = mediana (x1, x2, x3, x4, x5) y3 = mediana (y1, y2, y3, y4, y5) ecc.

Il metodo è rapido ed è anche facile da usare sui dati di streaming.

Ci sono alcuni dati positivi in ​​questa domanda / risposta.

Anche se tutto dipende da come i tuoi punti sono raggruppati su ciò che non funzionerà. Dovrai stare attento ai punti che sono sparsi ma non a valori anomali.

È possibile importare i dati in Excel o utilizzare i panda e la bandiera e / o eliminare tutte le distanze dal punto precedente che superano una soglia di distanza non realistica.