Détection et correction des valeurs aberrantes dans une trajectoire GPS

J'ai besoin de trouver un algorithme ou une méthode qui puisse détecter des latitude longitude points aberrants dans une trajectoire pendant le post-traitement , qui peut ensuite être corrigé (ramené dans le chemin de la trajectoire en fonction de ses voisins).

À titre d'exemple du type de points aberrants que je voudrais détecter et corriger, j'ai joint une image démontrant:

J'ai essayé d'utiliser un filtre de Kalman non parfumé pour lisser le mieux possible les données, mais cela ne semble pas fonctionner suffisamment efficacement pour les valeurs extrêmes plus extrêmes (données brutes en bleu, données lissées en rouge):

Mon UKF n'est peut-être pas calibré correctement (mais je suis assez certain qu'il l'est).

Les trajectoires sont celles des marcheurs, des coureurs, des cyclistes - des mouvements à propulsion humaine qui peuvent démarrer et s'arrêter, mais pas changer radicalement de vitesse ou de position aussi rapidement ou soudainement.

Une solution qui ne repose pas sur des données de synchronisation (et uniquement sur des données de position) serait extrêmement utile (car les données en cours de traitement ne contiennent pas toujours des données de synchronisation). Cependant, je suis conscient de l'improbabilité de ce type de solution, donc je suis tout aussi heureux d'avoir une solution!

Idéalement, la solution détecterait la valeur aberrante afin qu'elle puisse être corrigée, résultant en une trajectoire corrigée:

Ressources que j'ai passées en revue:

• 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 solution semble perdre la précision des données)

• Quel algorithme dois-je utiliser pour supprimer les valeurs aberrantes dans les données de trace?

Dans le cadre d'un outil de traitement des réseaux fluviaux, j'ai créé un outil de contrôle qualité pour rechercher des "pointes" dans le réseau. Bien que je ne vous suggère pas d'utiliser mon outil (comme c'est le cas pour le traitement des réseaux fluviaux), je vous montre le fichier d'aide qui montre une image de ce que j'ai fait.

J'avais développé un code autour de l'utilisation de la loi des cosinus pour identifier les angles successifs entre chaque segment de ligne d'une polyligne. Vous pouvez développer votre propre code autour de cette idée pour avancer le long d'une polyligne et identifier les angles extrêmes.

Algorithme que j'utilise.

1. Calculer l’arbre de points minimal euclidien:

2. Trouvez les 2 points les plus éloignés les uns des autres sur ce réseau

3. Trouvez l'itinéraire le plus court entre eux:

Comme on peut le voir, cela pourrait prendre un virage serré.

J'ai une implémentation ArcGIS python de l'algorithme ci-dessus, il utilise le module networkx. Faites-moi savoir si cela vous intéresse et je mettrai à jour ma réponse avec le script

MISE À JOUR:

# 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()            

Une idée est de créer un script qui répertorie les angles (et peut-être aussi la longueur) de chaque segment de votre chemin. Vous pouvez maintenant comparer les valeurs de chaque segment avec ses voisins directs (et éventuellement les seconds voisins également pour augmenter la précision) et sélectionner tous les points où les valeurs dépassent une valeur de seuil donnée. Enfin, supprimez simplement les points de votre chemin.

La méthode Median-5 mérite également d'être étudiée.

Chaque coordonnée x (ou y) est définie sur la médiane des 5 valeurs x (ou y) qui l'entourent en séquence (c'est-à-dire elle-même, les deux valeurs précédentes et les deux valeurs suivantes).

par exemple x3 = médiane (x1, x2, x3, x4, x5) y3 = médiane (y1, y2, y3, y4, y5) etc.

La méthode est rapide et est également facile à utiliser sur les données en streaming.

Il y a de bonnes données dans cette question / réponses.

Bien que tout dépende de la façon dont vos points sont regroupés sur ce qui fonctionnera / ne fonctionnera pas. Vous devrez être prudent sur les points étalés mais pas aberrants.

Vous pouvez importer vos données dans Excel ou utiliser des pandas et des drapeaux et / ou supprimer toutes les distances du point précédent qui dépassent un certain seuil de distance irréaliste.