vincenty and covering measurement time offset

static/scripts/accChart.js

@@ -1,3 +1,4 @@
+
 let allAccSerial = []
 let allSerialCoords = []
 let allTcpCoords = []
@@ -17,6 +18,16 @@ var accChart = new Chart(ctx, {
             lineTension: 0.5,
             data: []
         },
+        {
+            label: 'Smartphone Horizontal acc. (m)',
+            backgroundColor: 'rgb(185,190,45)',
+            borderColor: 'rgb(185,190,45)',
+            borderWidth: 1,
+            fill: false,
+            pointRadius: 0.5,
+            lineTension: 0.5,
+            data: []
+        },
         {
             label: 'Distance Ublox - Smartphone (m)',
             backgroundColor: 'rgba(30, 130, 76, 1)',
@@ -74,8 +85,7 @@ function addDistances(tcpDataList, serialDataList){
     })
 
     for(let i = 0; i < tcpCoords.length; i++){
-        let distance = distanceInMetersBetweenEarthCoordinates
+        let distance = distanceInMetersBetweenEarthCoordinates(serialCoords[i],tcpCoords[i])
-            (serialCoords[i][0],serialCoords[i][1],tcpCoords[i][0],tcpCoords[i][1])
         distances.push(distance)
     }
 
@@ -88,8 +98,41 @@ function addDistances(tcpDataList, serialDataList){
     accChart.update()
 }
 
+function addDistancesNew(data){
+    let serialHAccs = data.map(el => {
+        return el.ser.HAcc
+    })
+    let tcpHAccs = data.map(el => {
+        return el.tcp.HAcc
+    })
+
+    let distances = data.map((el, i, arr) => {
+        // return distVincenty(el.ser.Position, el.tcp.Position)
+        const plaindist = distVincenty(el.ser.Position, el.tcp.Position)
+        arr[i]['distance'] = plaindist
+        arr[i]['distanceClean'] = plaindist - (el.ser.Speed / 1000 * el.differenceMs)
+        arr[i]['distanceCleanAbs'] = plaindist - Math.abs(el.ser.Speed / 1000 * el.differenceMs)
+        return plaindist //- Math.abs(el.ser.Speed / 1000 * el.differenceMs)
+    })
+
+    let tcpTimes = data.map(el => {
+        return el.tcp.Timestamp
+    })
+
+    accChart.data.labels = tcpTimes
+    accChart.data.datasets[0].data = serialHAccs
+    accChart.data.datasets[1].data = tcpHAccs
+    accChart.data.datasets[2].data = distances
+    accChart.update()
+}
+
 //https://www.movable-type.co.uk/scripts/latlong.html
-function distanceInMetersBetweenEarthCoordinates(long1, lat1, long2, lat2) {
+function distanceInMetersBetweenEarthCoordinates(coord1, coord2) {
+    var long1 = coord1[0]
+    var lat1 = coord1[1]
+    var long2 = coord2[0]
+    var lat2 = coord2[1]
+
     var earthRadiusM = 6371000
 
     var phi1 = lat1 * Math.PI / 180
@@ -103,4 +146,50 @@ function distanceInMetersBetweenEarthCoordinates(long1, lat1, long2, lat2) {
             Math.sin(dlong/2) * Math.sin(dlong/2)
     var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
     return earthRadiusM * c
-}
+}
+
+
+Number.prototype.toRad = function () { return this * Math.PI / 180; }
+
+function distVincenty(coord1, coord2) {
+    const lon1 = coord1[0]
+    const lat1 = coord1[1]
+    const lon2 = coord2[0]
+    const lat2 = coord2[1]
+    var a = 6378137, b = 6356752.314245,  f = 1/298.257223563;  // WGS-84 ellipsoid params
+    var L = (lon2-lon1).toRad()
+    var U1 = Math.atan((1-f) * Math.tan(lat1.toRad()));
+    var U2 = Math.atan((1-f) * Math.tan(lat2.toRad()));
+    var sinU1 = Math.sin(U1), cosU1 = Math.cos(U1);
+    var sinU2 = Math.sin(U2), cosU2 = Math.cos(U2);
+
+    var lambda = L, lambdaP, iterLimit = 100;
+    do {
+        var sinLambda = Math.sin(lambda), cosLambda = Math.cos(lambda);
+        var sinSigma = Math.sqrt((cosU2*sinLambda) * (cosU2*sinLambda) +
+            (cosU1*sinU2-sinU1*cosU2*cosLambda) * (cosU1*sinU2-sinU1*cosU2*cosLambda));
+        if (sinSigma===0) return 0;  // co-incident points
+        var cosSigma = sinU1*sinU2 + cosU1*cosU2*cosLambda;
+        var sigma = Math.atan2(sinSigma, cosSigma);
+        var sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
+        var cosSqAlpha = 1 - sinAlpha*sinAlpha;
+        var cos2SigmaM = cosSigma - 2*sinU1*sinU2/cosSqAlpha;
+        if (isNaN(cos2SigmaM)) cos2SigmaM = 0;  // equatorial line: cosSqAlpha=0 (§6)
+        var C = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha));
+        lambdaP = lambda;
+        lambda = L + (1-C) * f * sinAlpha *
+            (sigma + C*sinSigma*(cos2SigmaM+C*cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)));
+    } while (Math.abs(lambda-lambdaP) > 1e-12 && --iterLimit>0);
+
+    if (iterLimit===0) return NaN  // formula failed to converge
+
+    var uSq = cosSqAlpha * (a*a - b*b) / (b*b);
+    var A = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)));
+    var B = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
+    var deltaSigma = B*sinSigma*(cos2SigmaM+B/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)-
+        B/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)));
+    var s = b*A*(sigma-deltaSigma);
+
+    s = s.toFixed(3); // round to 1mm precision
+    return s;
+}

static/scripts/refull.js

@@ -98,10 +98,10 @@ window.addEventListener("load", function(evt) {
         }).then(r => {
             console.log(r.data.Data)
             console.log(r.data)
-            if('SOURCE_TCP' in r.data.Data && r.data.Data.SOURCE_TCP.length > 0 && 'SOURCE_SERIAL' in r.data.Data && r.data.Data.SOURCE_SERIAL.length > 0){
+            // if('SOURCE_TCP' in r.data.Data && r.data.Data.SOURCE_TCP.length > 0 && 'SOURCE_SERIAL' in r.data.Data && r.data.Data.SOURCE_SERIAL.length > 0){
-                findSerialDataIndex(r.data.Data.SOURCE_TCP, r.data.Data.SOURCE_SERIAL)
+            //     findSerialDataIndex(r.data.Data.SOURCE_TCP, r.data.Data.SOURCE_SERIAL)
-                addDistances(r.data.Data.SOURCE_TCP, r.data.Data.SOURCE_SERIAL)
+            //     addDistances(r.data.Data.SOURCE_TCP, r.data.Data.SOURCE_SERIAL)
-            }
+            // }
             if ('SOURCE_TCP' in r.data.Data && r.data.Data.SOURCE_TCP.length > 0) {
                 updateMapTCPbulk(r.data.Data.SOURCE_TCP)
                 addTCPSpeedData(r.data.Data.SOURCE_TCP)
@@ -110,32 +110,43 @@ window.addEventListener("load", function(evt) {
                 updateMapSERIALbulk(r.data.Data.SOURCE_SERIAL)
                 addSerialSpeedData()
             }
-            if('SOURCE_TCP' in r.data.Data && r.data.Data.SOURCE_TCP.length > 0 && 'SOURCE_SERIAL' in r.data.Data && r.data.Data.SOURCE_SERIAL.length > 0) {
+            addDistancesNew(prepareForDistanceCalc(r.data.Data))
-                console.log("TEST")
-                let tcpSensorPoint = {};
-                let serSensorPoint = {};
-                r.data.Data.SOURCE_TCP.forEach(element => {
-                    // let ts = Date.parse(element.Timestamp)
-                    if (element.Position[0] !== 0 && element.Position[1] !== 0) {
-                        tcpSensorPoint = element
-                    }
-                })
-                console.log("TCP SENSORPOINT", tcpSensorPoint)
-                let smallestDifference = Number.MAX_VALUE
-                r.data.Data.SOURCE_SERIAL.forEach(element => {
-                    let tcpTS = Date.parse(tcpSensorPoint.Timestamp)
-                    let serTS = Date.parse(element.Timestamp)
-                    if (Math.abs(tcpTS - serTS) < smallestDifference) {
-                        smallestDifference = Math.abs(tcpTS - serTS)
-                        serSensorPoint = element
-                    }
-                })
-                console.log("SER SENSORPOINT", serSensorPoint)
-                console.log("smallest diff", smallestDifference)
 
-            }
         })
 
     }
 });
 
+function prepareForDistanceCalc(data) {
+    if('SOURCE_TCP' in data && data.SOURCE_TCP.length > 0 && 'SOURCE_SERIAL' in data && data.SOURCE_SERIAL.length > 0) {
+        let sensorPoints = [];
+        data.SOURCE_TCP.forEach(element => {
+            // let ts = Date.parse(element.Timestamp)
+            if (element.Position[0] !== 0 && element.Position[1] !== 0) {
+                sensorPoints.push({
+                    differenceMs: Number.MAX_VALUE,
+                    tcp: element,
+                    ser: null,
+                    speed: null
+                })
+            }
+        })
+        sensorPoints.forEach((el, index, arr) => {
+            let tcpTS = Date.parse(el.tcp.Timestamp)
+            data.SOURCE_SERIAL.forEach(serElement => {
+                let serTS = Date.parse(serElement.Timestamp)
+                if (Math.abs(tcpTS - serTS) < el.differenceMs && serElement.Position[0] !== 0 && serElement.Position[1] !== 0) {
+                    el.differenceMs = tcpTS - serTS
+                    arr[index].ser = serElement
+                }
+            })
+        })
+        // filter differences with more than 50 ms
+        let newSensorPoints = sensorPoints.filter(el => {
+            return Math.abs(el.differenceMs) < 50
+        })
+        console.log("SENSORPOINTs", newSensorPoints)
+        return newSensorPoints
+    }
+    return null
+}