incyclist-services 1.7.131 → 1.7.133

package/lib/cjs/activities/base/repo/db.js

@@ -240,6 +240,7 @@ let ActivitiesRepository = (() => {
             result = this.checkStartPosFilter(result, criteria);
             result = this.checkEndPosFilter(result, criteria);
             result = this.checkRealityFactorFilter(result, criteria);
+            result = this.checkSmoothingFilter(result, criteria);
             result = this.checkIsSavedFilter(result, criteria);
             result = this.checkUploadStatusFilter(result, criteria);
             result = this.checkTimeFilter(result, criteria);
@@ -287,6 +288,12 @@ let ActivitiesRepository = (() => {
             }
             return result;
         }
+        checkSmoothingFilter(result, criteria) {
+            if (result?.length > 0 && criteria?.smoothingLevel !== undefined) {
+                result = result.filter(ai => (ai.summary.smoothingLevel ?? 0) === criteria.smoothingLevel);
+            }
+            return result;
+        }
         checkIsSavedFilter(result, criteria) {
             if (result?.length > 0 && criteria?.isSaved !== undefined) {
                 result = result.filter(ai => ai.summary.isSaved === criteria.isSaved);

package/lib/cjs/activities/base/utils/activity.js

@@ -291,13 +291,14 @@ let Activity = (() => {
         }
         createStartSettings() {
             try {
-                const { startPos, realityFactor, segment, endPos } = this.details;
+                const { startPos, realityFactor, segment, endPos, smoothingLevel } = this.details;
                 const card = this.getRouteCard();
                 const settings = {
                     startPos,
                     endPos,
                     segment,
                     realityFactor,
+                    smoothingLevel,
                     showPrev: true,
                     type: card?.getCardType() ?? 'Route'
                 };

package/lib/cjs/activities/base/utils/helpers.js

@@ -18,7 +18,7 @@ exports.getActivityTotalElevation = exports.buildSummary = void 0;
 __exportStar(require("./activity"), exports);
 const model_1 = require("../model");
 const buildSummary = (activity, proposedName) => {
-    const { id, route, screenshots, startTime: startTimeUTC, time: rideTime, distance, startPos, endPos, realityFactor = 100, links, laps, fileName } = activity;
+    const { id, route, screenshots, startTime: startTimeUTC, time: rideTime, distance, startPos, endPos, realityFactor = 100, smoothingLevel, links, laps, fileName } = activity;
     let name = proposedName ?? activity.name;
     const routeId = route?.id;
     const routeHash = route?.hash;
@@ -48,7 +48,7 @@ const buildSummary = (activity, proposedName) => {
         uploadStatus.push({ service: 'strava', status: 'success' });
     }
     return {
-        id, title, name, routeId, routeHash, previewImage, startTime, rideTime, distance, totalElevation, startPos, endPos, realityFactor, uploadStatus, laps
+        id, title, name, routeId, routeHash, previewImage, startTime, rideTime, distance, totalElevation, startPos, endPos, realityFactor, smoothingLevel, uploadStatus, laps
     };
 };
 exports.buildSummary = buildSummary;

package/lib/cjs/activities/ride/service.js

@@ -841,7 +841,8 @@ let ActivityRideService = (() => {
                 const { startPos, realityFactor } = settings;
                 const routeId = this.activity.route.id;
                 const routeHash = this.activity.route.hash;
-                const filter = { routeId, routeHash, startPos, realityFactor, minTime: 30, minDistance: 500 };
+                const smoothingLevel = this.getRouteList().getAppliedSmoothingLevel();
+                const filter = { routeId, routeHash, startPos, realityFactor, smoothingLevel, minTime: 30, minDistance: 500 };
                 (0, list_1.useActivityList)()
                     .getPastActivitiesWithDetails(filter)
                     .then(prevRides => {
@@ -1025,8 +1026,9 @@ let ActivityRideService = (() => {
             const user = this.getUserSettings().get('user', {});
             const { weight, ftp } = user;
             const uuid = this.getUserSettings().get('uuid', undefined);
-            let selectedRoute = this.getRouteList().getSelected()?.clone();
+            let selectedRoute = this.getRouteList().getRideRoute();
             const startSettings = this.getRouteList().getStartSettings();
+            const smoothingLevel = this.getRouteList().getAppliedSmoothingLevel();
             this.tsStart = Date.now();
             const startTime = new Date(this.tsStart).toISOString();
             this.current = { deviceData: {}, dataState: {} };
@@ -1109,7 +1111,7 @@ let ActivityRideService = (() => {
                 distance: 0,
                 totalElevation: 0,
                 logs: [],
-                startPos, endPos, segment, realityFactor,
+                startPos, endPos, segment, realityFactor, smoothingLevel,
                 fileName,
                 sport
             };

package/lib/cjs/devices/page/statemachine.js

@@ -321,8 +321,9 @@ let PairingPageStateMachine = (() => {
                 this.performCheck();
             }
             else if (this.state === 'Pairing') {
-                this.getDevicePairing().stopPairing();
-                this.selectionTimeout = setTimeout(this.onDeviceSelectionTimeout.bind(this), 1000);
+                await this.getDevicePairing().stopPairing();
+                this._selectState = 'Active';
+                this.performCheck();
             }
         }
         resetTimeouts() {

package/lib/cjs/ride/display/service.js

@@ -308,6 +308,24 @@ let RideDisplayService = (() => {
         toggleRightSideView() {
             this.toggleOverlay('sv-right');
         }
+        isOverlayPinned(overlay) {
+            try {
+                return this.getUserSettings().get(`preferences.rideOverlays.${overlay}.pinned`, false);
+            }
+            catch (err) {
+                this.logError(err, 'isOverlayPinned');
+                return false;
+            }
+        }
+        setOverlayPinned(overlay, pinned) {
+            try {
+                this.getUserSettings().set(`preferences.rideOverlays.${overlay}.pinned`, pinned);
+                this.observer?.emit('overlay-update', this.getDisplayProperties());
+            }
+            catch (err) {
+                this.logError(err, 'setOverlayPinned');
+            }
+        }
         onArrowKey(event) {
             try {
                 const { key, shiftKey } = event;
@@ -371,7 +389,8 @@ let RideDisplayService = (() => {
                     hideAll: this.hideAll,
                     showShiftingButtons,
                     showDashboard,
-                    showWorkout
+                    showWorkout,
+                    shiftingPinned: this.isOverlayPinned('shifting')
                 };
                 const childProps = this.getRideModeService()?.getDisplayProperties(props) ?? {};
                 return { ...props, ...childProps };

package/lib/cjs/ride/route/RLVDisplayService.js

@@ -81,7 +81,7 @@ let RLVDisplayService = (() => {
             this.currentVideo = undefined;
             this.videos = [];
             delete this.startTime;
-            this.addVideo(this.getOriginalRoute(), true).then(() => {
+            this.addVideo(this.getRouteList().getRideRoute(), true).then(() => {
                 this.videosInitialized = true;
                 this.emit('state-update');
             });
@@ -559,7 +559,7 @@ let RLVDisplayService = (() => {
                 }
             }
             const current = this.videos.find(v => v.route?.details?.id === route.details.id);
-            const nextRoute = this.getRouteList().getRoute(nextId);
+            const nextRoute = this.getRouteList().getRideRoute(nextId);
             if (!nextRoute) {
                 return false;
             }

package/lib/cjs/ride/route/RouteDisplayService.js

@@ -97,7 +97,7 @@ let RouteDisplayService = (() => {
         }
         getDeviceStartSettings() {
             const startSettings = this.getRouteList().getStartSettings();
-            const route = this.getRouteList().getSelected();
+            const route = this.getRouteList().getRideRoute();
             const { realityFactor = 100, startPos = 0 } = startSettings;
             return { realityFactor, startPos, route };
         }
@@ -253,7 +253,7 @@ let RouteDisplayService = (() => {
             }
         }
         initRoute() {
-            this.currentRoute = this.getRouteList().getSelected().clone();
+            this.currentRoute = this.getRouteList().getRideRoute();
         }
         initView() { }
         get route() {

package/lib/cjs/routes/base/parsers/gpx.js

@@ -207,6 +207,7 @@ class GPXParser extends xml_1.XMLParser {
             points: route.points,
             requiresDownload: false,
             hasGpx: route.points?.length > 0,
+            pointsSource: 'gpx',
             hasVideo: false,
             isDemo: false,
             isLocal: true,

package/lib/cjs/routes/base/parsers/incyclist.js

@@ -14,6 +14,11 @@ class IncyclistXMLParser extends xml_1.XMLParser {
         super();
         this.logger = new gd_eventlog_1.EventLogger('IncyclistParser');
     }
+    async buildInfo(context) {
+        const info = await super.buildInfo(context);
+        info.pointsSource = 'gpx';
+        return info;
+    }
     async loadDescription(context) {
         await super.loadDescription(context);
         const title = context.data['title'];
@@ -159,12 +164,15 @@ class IncyclistXMLParser extends xml_1.XMLParser {
         if (data['cuts']) {
             this.processCuts(data, route);
         }
-        if (data['elevation-shift'])
-            this.processElevationShift(Number(data['elevation-shift']), route.points);
+        if (data['elevation-shift']) {
+            const applied = this.processElevationShift(Number(data['elevation-shift']), route.points);
+            if (applied)
+                route.elevationShifted = true;
+        }
     }
     processElevationShift(elevationShift, points) {
         if (!elevationShift || !points || points.length < 2 || points.length < elevationShift)
-            return;
+            return false;
         const cuts = points.filter(p => p.isCut) || [];
         const lastPoints = [];
         cuts.forEach(cut => {
@@ -189,6 +197,7 @@ class IncyclistXMLParser extends xml_1.XMLParser {
                 idx++;
             }
         });
+        return true;
     }
 }
 exports.IncyclistXMLParser = IncyclistXMLParser;

package/lib/cjs/routes/base/utils/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./route"), exports);
+__exportStar(require("./smoothing"), exports);

package/lib/cjs/routes/base/utils/smoothing.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyseElevationNoise = exports.getSmoothingGradient = exports.getSteepestGradient = exports.isSmoothingEligible = exports.applySmoothing = exports.smoothElevation = exports.getSmoothingProfile = exports.MAX_SMOOTHING_LEVEL = void 0;
+const route_1 = require("./route");
+const NOISE_REFERENCE_LEVEL = 3;
+const PROFILES = {
+    1: { windowLength: 30, passes: 1, spikeThreshold: 5 },
+    2: { windowLength: 60, passes: 1, spikeThreshold: 4 },
+    3: { windowLength: 120, passes: 2, spikeThreshold: 3 },
+    4: { windowLength: 250, passes: 2, spikeThreshold: 3 },
+    5: { windowLength: 500, passes: 2, spikeThreshold: 2 },
+};
+exports.MAX_SMOOTHING_LEVEL = 5;
+const NO_OP_PROFILE = {
+    windowLength: 0,
+    passes: 1,
+    spikeThreshold: Number.POSITIVE_INFINITY,
+};
+const getSmoothingProfile = (level) => {
+    if (!Number.isFinite(level))
+        return { ...NO_OP_PROFILE };
+    const rounded = Math.round(level);
+    if (rounded < 1)
+        return { ...NO_OP_PROFILE };
+    const clamped = Math.min(rounded, exports.MAX_SMOOTHING_LEVEL);
+    return { ...PROFILES[clamped] };
+};
+exports.getSmoothingProfile = getSmoothingProfile;
+const median3 = (a, b, c) => Math.max(Math.min(a, b), Math.min(Math.max(a, b), c));
+const getSegmentRanges = (points) => {
+    const ranges = [];
+    let start = 0;
+    for (let i = 1; i < points.length; i++) {
+        if (points[i]?.isCut === true) {
+            ranges.push([start, i]);
+            start = i;
+        }
+    }
+    ranges.push([start, points.length]);
+    return ranges;
+};
+const isUsable = (points, start, end) => {
+    for (let i = start; i < end; i++) {
+        const p = points[i];
+        if (!Number.isFinite(p?.elevation) || !Number.isFinite(p?.routeDistance))
+            return false;
+    }
+    return true;
+};
+const despikeRange = (points, start, end, threshold) => {
+    if (end - start < 3 || !Number.isFinite(threshold))
+        return;
+    const original = new Array(end - start);
+    for (let i = start; i < end; i++)
+        original[i - start] = points[i].elevation;
+    for (let i = start + 1; i < end - 1; i++) {
+        const m = median3(original[i - 1 - start], original[i - start], original[i + 1 - start]);
+        if (Math.abs(original[i - start] - m) > threshold)
+            points[i].elevation = m;
+    }
+};
+const boxFilterRange = (points, start, end, windowLength) => {
+    const n = end - start;
+    if (n < 3 || windowLength <= 0)
+        return;
+    const d = new Array(n);
+    const e = new Array(n);
+    for (let i = 0; i < n; i++) {
+        d[i] = points[start + i].routeDistance - points[start].routeDistance;
+        e[i] = points[start + i].elevation;
+    }
+    const total = d[n - 1];
+    if (total <= 0)
+        return;
+    const cum = new Array(n);
+    cum[0] = 0;
+    for (let i = 1; i < n; i++)
+        cum[i] = cum[i - 1] + ((e[i - 1] + e[i]) / 2) * (d[i] - d[i - 1]);
+    const cursor = { lower: 0, upper: 0 };
+    const integralAt = (x, which) => {
+        let j = cursor[which];
+        while (j < n - 2 && d[j + 1] < x)
+            j++;
+        cursor[which] = j;
+        if (x <= d[j])
+            return cum[j];
+        if (x >= d[j + 1])
+            return cum[j + 1];
+        const span = d[j + 1] - d[j];
+        const t = span > 0 ? (x - d[j]) / span : 0;
+        const ex = e[j] + (e[j + 1] - e[j]) * t;
+        return cum[j] + ((e[j] + ex) / 2) * (x - d[j]);
+    };
+    const smoothed = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const w = Math.min(windowLength, 2 * d[i], 2 * (total - d[i]));
+        if (w <= 0) {
+            smoothed[i] = e[i];
+            continue;
+        }
+        const value = (integralAt(d[i] + w / 2, 'upper') - integralAt(d[i] - w / 2, 'lower')) / w;
+        smoothed[i] = Number.isFinite(value) ? value : e[i];
+    }
+    for (let i = 0; i < n; i++)
+        points[start + i].elevation = smoothed[i];
+};
+const LAG_SHIFT_RATIO = 0.15;
+const getLagShiftDistance = (opts) => opts.passes === 2 ? opts.windowLength * LAG_SHIFT_RATIO : 0;
+const buildElevationLookup = (d, e) => {
+    const n = d.length;
+    let cursor = 0;
+    return (x) => {
+        if (x >= d[n - 1]) {
+            const span = d[n - 1] - d[n - 2];
+            const slope = span > 0 ? (e[n - 1] - e[n - 2]) / span : 0;
+            return e[n - 1] + slope * (x - d[n - 1]);
+        }
+        while (cursor < n - 2 && d[cursor + 1] < x)
+            cursor++;
+        if (x <= d[cursor])
+            return e[cursor];
+        const span = d[cursor + 1] - d[cursor];
+        const t = span > 0 ? (x - d[cursor]) / span : 0;
+        return e[cursor] + (e[cursor + 1] - e[cursor]) * t;
+    };
+};
+const applyLagShift = (points, start, end, shiftDistance) => {
+    const n = end - start;
+    if (n < 2 || shiftDistance <= 0)
+        return;
+    const d = new Array(n);
+    const e = new Array(n);
+    for (let i = 0; i < n; i++) {
+        d[i] = points[start + i].routeDistance - points[start].routeDistance;
+        e[i] = points[start + i].elevation;
+    }
+    if (d[n - 1] <= 0)
+        return;
+    const elevationAt = buildElevationLookup(d, e);
+    const reference = elevationAt(shiftDistance);
+    for (let i = 0; i < n; i++) {
+        points[start + i].elevation = e[0] + elevationAt(d[i] + shiftDistance) - reference;
+    }
+};
+const LOOP_PADDING_DISTANCE = 800;
+const padForLoop = (points, padDistance) => {
+    const total = points.at(-1)?.routeDistance ?? 0;
+    if (total <= 0)
+        return { padded: points, headCount: 0 };
+    const tail = points.filter((p) => total - p.routeDistance <= padDistance);
+    const head = points.filter((p) => p.routeDistance <= padDistance);
+    const before = tail.map((p) => ({ ...p, routeDistance: p.routeDistance - total, isCut: false }));
+    const after = head.map((p) => ({ ...p, routeDistance: p.routeDistance + total, isCut: false }));
+    return { padded: [...before, ...points, ...after], headCount: before.length };
+};
+const smoothElevation = (points, opts) => {
+    if (!points?.length)
+        return [];
+    const result = points.map((p) => ({ ...p }));
+    if (!opts)
+        return result;
+    const passes = opts.passes === 2 ? 2 : 1;
+    const lagShiftDistance = getLagShiftDistance(opts);
+    getSegmentRanges(result).forEach(([start, end]) => {
+        if (!isUsable(result, start, end))
+            return;
+        despikeRange(result, start, end, opts.spikeThreshold);
+        for (let pass = 0; pass < passes; pass++)
+            boxFilterRange(result, start, end, opts.windowLength);
+        applyLagShift(result, start, end, lagShiftDistance);
+    });
+    return result;
+};
+exports.smoothElevation = smoothElevation;
+const applySmoothing = (route, level) => {
+    const smoothed = route?.clone();
+    if (!smoothed)
+        return smoothed;
+    if (!Number.isFinite(level) || level < 1)
+        return smoothed;
+    const source = smoothed.details?.points ?? smoothed.description?.points;
+    if (!source?.length)
+        return smoothed;
+    const profile = (0, exports.getSmoothingProfile)(level);
+    let points;
+    if ((0, route_1.checkIsLoop)(source)) {
+        const { padded, headCount } = padForLoop(source, LOOP_PADDING_DISTANCE);
+        points = (0, exports.smoothElevation)(padded, profile).slice(headCount, headCount + source.length);
+    }
+    else {
+        points = (0, exports.smoothElevation)(source, profile);
+    }
+    if (smoothed.details?.points)
+        smoothed.details.points = points;
+    if (smoothed.description?.points)
+        smoothed.description.points = points;
+    points.forEach((p) => {
+        delete p.slope;
+        delete p.elevationGain;
+    });
+    if (points.some((p) => !Number.isFinite(p.cnt)))
+        (0, route_1.updateCnt)(points);
+    (0, route_1.updateSlopes)(points, false);
+    (0, route_1.updateElevationGain)(points);
+    const elevation = points.at(-1)?.elevationGain;
+    if (Number.isFinite(elevation)) {
+        if (smoothed.description)
+            smoothed.description.elevation = elevation;
+        if (smoothed.details)
+            smoothed.details.elevation = elevation;
+    }
+    return smoothed;
+};
+exports.applySmoothing = applySmoothing;
+const MIN_ELIGIBLE_POINTS = 8;
+const getRoutePoints = (route) => {
+    const points = route?.points ?? route?.details?.points ?? route?.description?.points;
+    return Array.isArray(points) ? points : [];
+};
+const isVideoRoute = (route) => route?.description?.hasVideo === true || route?.details?.video !== undefined;
+const isInScopeVideoRoute = (route) => {
+    if (route?.description?.pointsSource === 'gpx')
+        return true;
+    const points = route?.details?.points;
+    if (!Array.isArray(points))
+        return false;
+    return points.some((p) => p?.isCut === true) || points.some((p) => Number.isFinite(p?.time));
+};
+const isSmoothingEligible = (route) => {
+    try {
+        const points = getRoutePoints(route);
+        if (points.length < MIN_ELIGIBLE_POINTS)
+            return false;
+        if (!points.every((p) => Number.isFinite(p?.elevation)))
+            return false;
+        if (new Set(points.map((p) => Math.round(p.elevation))).size < 2)
+            return false;
+        if (!points.some((p) => p?.lat && p?.lng))
+            return false;
+        if (route?.description?.hasGpx === false)
+            return false;
+        if (route?.details?.gpxDisabled)
+            return false;
+        if (route?.details?.elevationShifted)
+            return false;
+        if (route?.details?.epp)
+            return false;
+        return !isVideoRoute(route) || isInScopeVideoRoute(route);
+    }
+    catch {
+        return false;
+    }
+};
+exports.isSmoothingEligible = isSmoothingEligible;
+const getSteepestGradient = (points) => {
+    if (!Array.isArray(points))
+        return 0;
+    let steepest = 0;
+    for (const p of points) {
+        const slope = p?.slope;
+        if (!Number.isFinite(slope))
+            continue;
+        const magnitude = Math.abs(slope);
+        if (magnitude > steepest)
+            steepest = magnitude;
+    }
+    return steepest;
+};
+exports.getSteepestGradient = getSteepestGradient;
+const MIN_VISIBLE_GRADIENT_DELTA = 0.5;
+const MIN_VISIBLE_GAIN_RATIO = 0.02;
+const getSmoothingGradient = (routePoints, smoothedPoints, routeGain, smoothedGain) => {
+    const routeSteepest = (0, exports.getSteepestGradient)(routePoints);
+    const smoothedSteepest = (0, exports.getSteepestGradient)(smoothedPoints);
+    const gradientDelta = Math.abs(routeSteepest - smoothedSteepest);
+    const gainRatio = Number.isFinite(routeGain) && routeGain > 0 && Number.isFinite(smoothedGain)
+        ? Math.abs(routeGain - smoothedGain) / routeGain
+        : 0;
+    const hasVisibleEffect = gradientDelta >= MIN_VISIBLE_GRADIENT_DELTA || gainRatio >= MIN_VISIBLE_GAIN_RATIO;
+    return { routeSteepest, smoothedSteepest, hasVisibleEffect };
+};
+exports.getSmoothingGradient = getSmoothingGradient;
+const getElevationGain = (points) => {
+    let gain = 0;
+    for (let i = 1; i < points.length; i++) {
+        const delta = points[i].elevation - points[i - 1].elevation;
+        if (delta > 0)
+            gain += delta;
+    }
+    return gain;
+};
+const getMedian = (values) => {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+};
+const analyseElevationNoise = (points) => {
+    const empty = { gainRatio: 1, reversalDensity: 0, pointCount: 0, medianSpacing: 0 };
+    if (!points?.length)
+        return empty;
+    const usable = points.filter((p) => Number.isFinite(p?.elevation) && Number.isFinite(p?.routeDistance));
+    if (usable.length < 2)
+        return { ...empty, pointCount: points.length };
+    const spacings = [];
+    let reversals = 0;
+    let prevSign = 0;
+    for (let i = 1; i < usable.length; i++) {
+        const dd = usable[i].routeDistance - usable[i - 1].routeDistance;
+        if (dd > 0)
+            spacings.push(dd);
+        const de = usable[i].elevation - usable[i - 1].elevation;
+        const sign = Math.sign(de);
+        if (sign !== 0) {
+            if (prevSign !== 0 && sign !== prevSign)
+                reversals++;
+            prevSign = sign;
+        }
+    }
+    const distanceKm = (usable.at(-1).routeDistance - usable[0].routeDistance) / 1000;
+    const rawGain = getElevationGain(usable);
+    const smoothedGain = getElevationGain((0, exports.smoothElevation)(usable, (0, exports.getSmoothingProfile)(NOISE_REFERENCE_LEVEL)));
+    const gainRatio = smoothedGain > 0 ? rawGain / smoothedGain : 1;
+    return {
+        gainRatio,
+        reversalDensity: distanceKm > 0 ? reversals / distanceKm : 0,
+        pointCount: points.length,
+        medianSpacing: getMedian(spacings),
+    };
+};
+exports.analyseElevationNoise = analyseElevationNoise;

package/lib/cjs/routes/list/cards/RouteCard.js

@@ -47,6 +47,7 @@ const utils_1 = require("../../../utils");
 const service_2 = require("../../download/service");
 const gd_eventlog_1 = require("gd-eventlog");
 const route_1 = require("../../base/utils/route");
+const smoothing_1 = require("../../base/utils/smoothing");
 const workouts_1 = require("../../../workouts");
 const utils_2 = require("../utils");
 const monitoring_1 = require("../../../monitoring");
@@ -103,6 +104,7 @@ let RouteCard = (() => {
         ready;
         logger;
         cntActive = 0;
+        smoothingPreview;
         constructor(route, props) {
             super();
             const { list } = props || {};
@@ -412,8 +414,11 @@ let RouteCard = (() => {
             const totalElevation = { value: C(this.route.description.elevation, 'elevation', { digits: 0 }), unit: uEl };
             const xScale = { value: C(1, 'distance'), unit: uDist };
             const yScale = { value: C(1, 'elevation'), unit: uEl };
+            const smoothingAvailable = this.isSmoothingAvailable();
+            const { smoothedPoints, smoothedElevation, smoothedGradient } = this.getSmoothingPreview(uiSettings.smoothingLevel);
             return { settings: uiSettings, totalDistance, totalElevation, showLoopOverwrite, showNextOverwrite, hasWorkout, showWorkoutOption, canStart, videoChecking, videoMissing, detailsAvailable,
                 xScale, yScale,
+                smoothingAvailable, smoothingMaxLevel: smoothing_1.MAX_SMOOTHING_LEVEL, smoothedPoints, smoothedElevation, smoothedGradient,
                 updateStartPos: this.updateStartPos.bind(this),
                 updateMarkers: this.updateMarkers.bind(this)
             };
@@ -446,19 +451,21 @@ let RouteCard = (() => {
                 delete props.prevRides;
                 if (isUI) {
                     const uiProps = props;
-                    const { realityFactor, segment, showPrev, loopOverwrite, nextOverwrite } = uiProps;
+                    const { realityFactor, segment, showPrev, loopOverwrite, nextOverwrite, smoothingLevel } = uiProps;
                     const startPos = C(uiProps.startPos.value, 'distance', { from: U('distance'), to: 'm' }) ?? 0;
                     const endPos = uiProps.endPos === undefined ? undefined : C(uiProps.endPos.value, 'distance', { from: U('distance'), to: 'm' });
                     this.startSettings = {
                         ...this.startSettings,
-                        startPos, endPos, realityFactor, segment, showPrev, loopOverwrite, nextOverwrite
+                        startPos, endPos, realityFactor, segment, showPrev, loopOverwrite, nextOverwrite,
+                        smoothingLevel: smoothingLevel ?? this.startSettings?.smoothingLevel
                     };
                 }
                 else {
-                    const { startPos, endPos, realityFactor, segment, showPrev, loopOverwrite, nextOverwrite } = props;
+                    const { startPos, endPos, realityFactor, segment, showPrev, loopOverwrite, nextOverwrite, smoothingLevel } = props;
                     this.startSettings = {
                         ...this.startSettings,
-                        startPos, endPos, realityFactor, segment, showPrev, loopOverwrite, nextOverwrite
+                        startPos, endPos, realityFactor, segment, showPrev, loopOverwrite, nextOverwrite,
+                        smoothingLevel: smoothingLevel ?? this.startSettings?.smoothingLevel
                     };
                 }
                 const userSettings = (0, settings_1.useUserSettings)();
@@ -470,6 +477,59 @@ let RouteCard = (() => {
                 this.logError(err, 'changeSettings');
             }
         }
+        getSmoothingPreview(level) {
+            const none = {};
+            try {
+                if (!Number.isFinite(level) || level < 1)
+                    return none;
+                if (!this.isSmoothingAvailable())
+                    return none;
+                const key = `${this.getRouteDescription()?.id}:${Math.round(level)}`;
+                if (this.smoothingPreview?.key !== key) {
+                    const smoothed = (0, smoothing_1.applySmoothing)(this.route, level);
+                    const points = smoothed?.points;
+                    if (!points?.length)
+                        return none;
+                    const elevation = smoothed.description?.elevation ?? smoothed.details?.elevation;
+                    const routeElevation = this.route.description?.elevation ?? this.route.details?.elevation;
+                    this.smoothingPreview = {
+                        key,
+                        points,
+                        elevation,
+                        gradient: (0, smoothing_1.getSmoothingGradient)(this.route.points, points, routeElevation, elevation)
+                    };
+                }
+                const { points: smoothedPoints, elevation, gradient } = this.smoothingPreview;
+                const [C, U] = (0, i18n_1.getUnitConversionShortcuts)();
+                return {
+                    smoothedPoints,
+                    smoothedElevation: Number.isFinite(elevation)
+                        ? { value: C(elevation, 'elevation', { digits: 0 }), unit: U('elevation') }
+                        : undefined,
+                    smoothedGradient: gradient
+                };
+            }
+            catch (err) {
+                this.logError(err, 'getSmoothingPreview');
+                return none;
+            }
+        }
+        isSmoothingAvailable() {
+            return (0, smoothing_1.isSmoothingEligible)(this.route);
+        }
+        getPrevRidesFilter(settings) {
+            const routeHash = this.getRouteDescription()?.routeHash;
+            const routeId = routeHash ? undefined : this.getRouteDescription()?.id;
+            const smoothingLevel = this.isSmoothingAvailable() ? (settings.smoothingLevel ?? 0) : 0;
+            return {
+                routeHash,
+                routeId,
+                startPos: settings.startPos,
+                endPos: settings.endPos,
+                realityFactor: settings.realityFactor,
+                smoothingLevel,
+            };
+        }
         adjustStartPosAvi(settings) {
             try {
                 if (this.route.description.videoFormat === 'avi') {