Merge branch 'master' of https://github.com/RideTracker/RouteService

Author: nora-soderlund

package-lock.json

@@ -8,6 +8,7 @@
     "author": "Nora Söderlund",
     "devDependencies": {
         "@cloudflare/workers-types": "^4.20230518.0",
+        "@types/geolib": "^2.0.23",
         "@types/itty-router-extras": "^0.4.0",
         "@types/react": "^18.2.6",
         "sass": "^1.62.1",
@@ -17,6 +18,7 @@
     "dependencies": {
         "@ridetracker/authservice": "^0.9.2",
         "@ridetracker/discordwebhooksclient": "^0.9.0",
+        "geolib": "^3.3.4",
         "itty-router": "^3.0.12",
         "itty-router-extras": "^0.4.2",
         "react": "^18.2.0",

package.json

@@ -1,4 +1,4 @@
-import { Session } from "../../models/Session";
+import { Session } from "../../../models/Session";
 
 export default async function getActivitySessions(bucket: R2Bucket, activityId: string): Promise<Session[] | null> {
     const activity = await bucket.get(`activities/${activityId}.json`);

…ollers/activities/getActivitySessions.ts …tivities/sessions/getActivitySessions.tssrc/controllers/activities/getActivitySessions.ts renamed to src/controllers/activities/sessions/getActivitySessions.ts src/controllers/activities/getActivitySessions.ts renamed to src/controllers/activities/sessions/getActivitySessions.ts

@@ -0,0 +1,11 @@
+import { Session } from "../../../../models/Session";
+import { SessionsInsights } from "../../../../models/SessionsInsights";
+
+export default async function createActivitySessionsInsights(bucket: R2Bucket, activityId: string, insights: SessionsInsights): Promise<void> {
+    await bucket.put(`activities/insights/${activityId}.json`, JSON.stringify(insights), {
+        customMetadata: {
+            "type": "insights",
+            "activity": activityId
+        }
+    });
+};

src/controllers/activities/sessions/insights/createActivitySessionsInsights.ts

@@ -0,0 +1,10 @@
+import { Session } from "../../../../models/Session";
+
+export default async function getActivitySessionsInsights(bucket: R2Bucket, activityId: string): Promise<Session[] | null> {
+    const activity = await bucket.get(`activities/insights/${activityId}.json`);
+
+    if(!activity)
+        return null;
+
+    return await activity.json<Session[]>();
+};

src/controllers/activities/sessions/insights/getActivitySessionsInsights.ts

@@ -0,0 +1,94 @@
+import { Coordinate } from "../../models/Coordinate";
+import { Session } from "../../models/Session";
+import { getDistance } from "geolib";
+
+const significantChange = 1;
+
+// TODO: change to be a percentage of overall distance
+const significantDistance = 100;
+
+export default function getSignificantAltitudeChanges(locations: Session["locations"]) {
+    const points: {
+        coordinate: Coordinate;
+        altitude: number;
+        distance: number;
+    }[] = [];
+
+    if(!locations.length)
+        return [];
+
+    const start = locations[0];
+    const end = locations[1];
+
+    let accumulatedDistance = 0;
+
+    points.push({
+        coordinate: {
+            latitude: start.coords.latitude,
+            longitude: start.coords.longitude
+        },
+
+        altitude: start.coords.altitude,
+
+        distance: accumulatedDistance
+    });
+
+    for(let index = 1; index < locations.length - 1; index++) {
+        const location = locations[index];
+        const previous = points[points.length - 1];
+
+        const distance = getDistance(previous.coordinate, location.coords);
+
+        accumulatedDistance += getDistance(locations[index - 1].coords, location.coords);
+
+        if(distance < significantDistance) {
+            //console.log(`Skipping coordinate because ${distance} m is less than 100 m`);
+
+            continue;
+        }
+        
+        const difference = Math.abs(location.coords.altitude - previous.altitude);
+
+        if(difference < significantChange) {
+            //console.log(`Skipping altitude change because ${difference} is less than significant change of ${significantChange}`);
+
+            continue;
+        }
+
+        if(difference < location.coords.altitudeAccuracy) {
+            //console.log(`Skipping altitude elevation because ${difference} is less than accuracy of ${location.coords.altitudeAccuracy}`);
+
+            continue;
+        }
+        
+        points.push({
+            coordinate: {
+                latitude: location.coords.latitude,
+                longitude: location.coords.longitude
+            },
+
+            altitude: location.coords.altitude,
+
+            distance: accumulatedDistance
+        });
+    }
+    
+    if(locations.length > 1) {
+        const location = locations[locations.length - 1];
+
+        accumulatedDistance += getDistance(locations[locations.length - 2].coords, location.coords);
+
+        points.push({
+            coordinate: {
+                latitude: end.coords.latitude,
+                longitude: end.coords.longitude
+            },
+
+            altitude: end.coords.altitude,
+
+            distance: accumulatedDistance
+        });
+    }
+        
+    return points;
+};

src/controllers/polylines/getSignificantAltitudeChanges.ts

@@ -0,0 +1,87 @@
+import { Coordinate } from "../../models/Coordinate";
+import { Session } from "../../models/Session";
+import { getDistance } from "geolib";
+
+const significantChange = 4;
+
+// TODO: change to be a percentage of overall distance
+const significantDistance = 100;
+
+export default function getSignificantSpeedChanges(locations: Session["locations"]) {
+    const points: {
+        coordinate: Coordinate;
+        speed: number;
+        distance: number;
+    }[] = [];
+
+    if(!locations.length)
+        return [];
+
+    const start = locations[0];
+    const end = locations[1];
+
+    let accumulatedDistance = 0;
+
+    points.push({
+        coordinate: {
+            latitude: start.coords.latitude,
+            longitude: start.coords.longitude
+        },
+
+        speed: start.coords.speed,
+        distance: 0
+    });
+
+    for(let index = 1; index < locations.length - 1; index++) {
+        const location = locations[index];
+        const previous = points[points.length - 1];
+
+        const distance = getDistance(previous.coordinate, location.coords);
+
+        accumulatedDistance += getDistance(locations[index - 1].coords, location.coords);
+
+        if(distance < significantDistance) {
+            //console.log(`Skipping coordinate because ${distance} m is less than 100 m`);
+
+            continue;
+        }
+        
+        const difference = Math.abs(location.coords.speed - previous.speed);
+
+        if(difference < significantChange) {
+            //console.log(`Skipping speed change because ${difference} is less than significant change of ${significantChange}`);
+
+            continue;
+        }
+        
+        points.push({
+            coordinate: {
+                latitude: location.coords.latitude,
+                longitude: location.coords.longitude
+            },
+
+            speed: location.coords.speed,
+
+            distance: accumulatedDistance
+        });
+    }
+    
+    if(locations.length > 1) {
+        const location = locations[locations.length - 1];
+
+        accumulatedDistance += getDistance(locations[locations.length - 2].coords, location.coords);
+
+        points.push({
+            coordinate: {
+                latitude: end.coords.latitude,
+                longitude: end.coords.longitude
+            },
+
+            speed: end.coords.speed,
+
+            distance: accumulatedDistance
+        });
+    }
+
+    return points;
+};

src/controllers/polylines/getSignificantSpeedChanges.ts

@@ -0,0 +1,10 @@
+export default function getSignificantStats(items: number[]) {
+    const sum = items.reduce((accumulated, speed) => accumulated + speed, 0);
+    const average = sum / items.length;
+
+    return {
+        minimum: Math.min(...items),
+        maximum: Math.max(...items),
+        average
+    };
+};

src/controllers/polylines/getSignificantStats.ts

@@ -0,0 +1,17 @@
+import { getDistance } from "geolib";
+import { Coordinate } from "../../models/Coordinate";
+
+export default function getStrippedPolylineByCoordinates(points: Coordinate[], distance: number): (any & Coordinate)[] {
+    let filteredCoordinates = [
+        points[0]
+    ];
+
+    for(let index = 1; index < points.length - 1; index++) {
+        if(getDistance(points[index], filteredCoordinates[filteredCoordinates.length - 1]) >= distance)
+            filteredCoordinates.push(points[index]);
+    }
+
+    filteredCoordinates.push(points[points.length - 1]);
+
+    return filteredCoordinates;
+};

src/controllers/polylines/getStrippedPolyline.ts

@@ -3,13 +3,15 @@ import { handleActivityRouteRequest } from "../routes/activities/[activityId]/ro
 import { handleActivitySessionsRequest } from "../routes/activities/[activityId]/sessions";
 import { withAuth } from "@ridetracker/authservice";
 import { handleActivitySessionsAltitudeRequest } from "../routes/activities/[activityId]/sessions/altitude";
+import { handleActivitySessionsSpeedRequest } from "../routes/activities/[activityId]/sessions/speed";
+import { handleActivitySessionsInsightsRequest } from "../routes/activities/[activityId]/sessions/insights";
 
 export default function createRouter() {
     const router = ThrowableRouter();
 
     router.get("/activities/:activityId/route", withAuth("user", "DATABASE"), withParams, handleActivityRouteRequest);
     router.get("/api/activities/:activityId/sessions", withAuth("user", "DATABASE"), withParams, handleActivitySessionsRequest);
-    router.get("/api/activities/:activityId/sessions/altitude", withAuth("user", "DATABASE"), withParams, handleActivitySessionsAltitudeRequest);
+    router.get("/api/activities/:activityId/sessions/insights", withAuth("user", "DATABASE"), withParams, handleActivitySessionsInsightsRequest);
 
     return router;
 };