incyclist-services 1.3.19 → 1.3.21

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

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IncyclistXMLParser = void 0;
+const utils_1 = require("../../../utils");
 const gpx_1 = require("./gpx");
 const xml_1 = require("./xml");
 class IncyclistXMLParser extends xml_1.XMLParser {
@@ -49,16 +50,59 @@ class IncyclistXMLParser extends xml_1.XMLParser {
             route.points = gpx.details.points;
         });
     }
+    processCuts(data, route) {
+        const cuts = data['cuts'];
+        cuts === null || cuts === void 0 ? void 0 : cuts.forEach(cut => {
+            const timeStr = cut['time'];
+            const time = (0, utils_1.parseTime)(timeStr);
+            const cutInfo = { time, startFrame: cut['start-frame'], endFrame: cut['end-frame'] };
+            const mappings = route.video.mappings;
+            const points = route.points;
+            if (!mappings || !points)
+                return;
+            const mappingAtCutIdx = mappings.findIndex(p => p.time === cutInfo.time);
+            const mappingAtCut = mappings[mappingAtCutIdx];
+            const mappingBeforeCut = mappings[mappingAtCutIdx - 1];
+            const distanceToCut = points.map((p, index) => {
+                const distance = Math.abs(p.routeDistance - mappingAtCut.distance);
+                return { index, distance };
+            }).sort((a, b) => a.distance - b.distance);
+            const pointAtCut = points[distanceToCut[0].index];
+            const pointBeforeCut = points[distanceToCut[0].index - 1];
+            const v = mappingAtCut.videoSpeed / 3.6;
+            const t = mappingAtCut.time - mappingBeforeCut.time;
+            const distanceAtCutStart = pointAtCut.routeDistance - v * t;
+            const offset = distanceAtCutStart - pointBeforeCut.routeDistance;
+            pointAtCut.routeDistance -= offset;
+            pointAtCut.distance -= offset;
+            pointAtCut.isCut = true;
+            points.forEach((p, idx) => {
+                if (idx > distanceToCut[0].index) {
+                    p.routeDistance -= offset;
+                }
+            });
+            mappingBeforeCut.videoSpeed = mappingAtCut.videoSpeed;
+            mappings.forEach((m, idx) => {
+                if (idx >= mappingAtCutIdx) {
+                    m.distance -= Math.round(offset);
+                }
+            });
+        });
+        route.distance = route.points[route.points.length - 1].routeDistance;
+    }
     parseVideo(context) {
         const _super = Object.create(null, {
             parseVideo: { get: () => super.parseVideo }
         });
         return __awaiter(this, void 0, void 0, function* () {
             yield _super.parseVideo.call(this, context);
-            const { route } = context;
+            const { data, route } = context;
             const points = route.points;
             route.video.mappings = points.map((p, idx) => {
                 const time = p.time;
+                if (time > 1659) {
+                    let i = 1;
+                }
                 let videoSpeed;
                 if (idx !== points.length - 1) {
                     videoSpeed = (points[idx + 1].routeDistance - p.routeDistance) / (points[idx + 1].time - p.time) * 3.6;
@@ -66,11 +110,16 @@ class IncyclistXMLParser extends xml_1.XMLParser {
                 else {
                     videoSpeed = points[idx - 1].videoSpeed;
                 }
+                if (p.distance > 500) {
+                }
                 const distance = Math.round(p.routeDistance);
                 const frame = Math.round(p.time * route.video.framerate);
                 delete p.time;
                 return { time, videoSpeed, distance, frame };
             });
+            if (data['cuts']) {
+                this.processCuts(data, route);
+            }
         });
     }
 }

package/lib/routes/base/parsers/types.d.ts

@@ -8,3 +8,8 @@ export type Altitude = {
     distance?: string;
     height?: string;
 };
+export type CutInfo = {
+    time: number;
+    startFrame?: number;
+    endFrame?: number;
+};

package/lib/routes/base/types/index.d.ts

@@ -1,4 +1,5 @@
 import { FileInfo } from "../../../api";
+import { LatLng } from "../../../utils/geo";
 export type RouteType = 'gpx' | 'video';
 export type RouteCategory = 'Imported' | 'Free' | 'Demo' | 'personal';
 export type RouteState = 'prepared' | 'loading' | 'loaded' | 'error';
@@ -54,11 +55,9 @@ export type DaumEpp = {
     speedLimit: number;
     programData: Array<DaumEppProgramEntry>;
 };
-export type RoutePoint = {
+export interface RoutePoint extends LatLng {
     cnt?: number;
     heading?: number;
-    lat: number;
-    lng: number;
     routeDistance: number;
     elevation: number;
     elevationGain?: number;
@@ -66,7 +65,8 @@ export type RoutePoint = {
     distance?: number;
     videoSpeed?: number;
     videoTime?: number;
-};
+    isCut?: boolean;
+}
 export interface VideoRoutePoint extends RoutePoint {
     videoSpeed: number;
     videoTime: number;

package/lib/routes/base/types/index.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+;

package/lib/routes/download/service.js

@@ -85,6 +85,10 @@ class RouteDownloadService extends service_1.IncyclistService {
                     return;
                 }
                 const info = path.parse(url);
+                if (!info) {
+                    this.logEvent({ message: 'no URL specified', description: route.description });
+                    observer.emit('error', new Error('no URL specified'));
+                }
                 const file = path.join(targetDir, info.base);
                 const session = downloadManager.createSession(url, file);
                 observer.setSession(session);
@@ -100,7 +104,7 @@ class RouteDownloadService extends service_1.IncyclistService {
                 session.start();
             }
             catch (err) {
-                this.logError(err, 'downloadRoute', url);
+                this.logError(err, 'downloadRoute', { url });
                 observer.emit('error', err);
             }
         });

package/lib/settings/user/service.js

@@ -151,7 +151,7 @@ class UserSettingsService {
     }
     updateSettings(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isInitialized)
+            if (!this.isInitialized || !this.settings)
                 throw new Error('Settings are not yet initialized');
             try {
                 (0, merge_1.merge)(this.settings, data);

package/lib/utils/geo.d.ts

@@ -12,3 +12,4 @@ export declare const getPointBetween: (p1: LatLng, p2: LatLng, offset: number) =
 export declare const getPointAfter: (p1: LatLng, p2: LatLng, offset: number) => LatLng;
 export declare const getLatLng: (position: LatLng | Array<number>) => LatLng;
 export declare const calculateHeaderFromPoints: (p1: LatLng, p2: LatLng) => number;
+export declare function crossing(AB: any, CD: any, AC: any): any;

package/lib/utils/geo.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateHeaderFromPoints = exports.getLatLng = exports.getPointAfter = exports.getPointBetween = exports.distanceBetween = exports.calculateDistance = void 0;
+exports.crossing = exports.calculateHeaderFromPoints = exports.getLatLng = exports.getPointAfter = exports.getPointBetween = exports.distanceBetween = exports.calculateDistance = void 0;
 const math_1 = require("./math");
+const vector_1 = require("./vector");
 const rEarth = 6378.100;
 const calculateDistance = (lat1, lon1, lat2, lon2, radius = rEarth * 1000) => {
     const R = radius;
@@ -72,3 +73,58 @@ const calculateHeaderFromPoints = (p1, p2) => {
     }
 };
 exports.calculateHeaderFromPoints = calculateHeaderFromPoints;
+function crossing(AB, CD, AC) {
+    if (AB === undefined || (!vector_1.Vector.isVector(AB) && !Array.isArray(AB)))
+        throw new Error('AB is not a vector');
+    if (CD === undefined || (!vector_1.Vector.isVector(CD) && !Array.isArray(CD)))
+        throw new Error('CD is not a vector');
+    if (AC === undefined || (!vector_1.Vector.isVector(AC) && !Array.isArray(AC)))
+        throw new Error('AC is not a vector');
+    if (AB.isParallel(CD)) {
+        if (!AB.isParallel(AC))
+            return undefined;
+        if (AB.isSameDirection(CD)) {
+            if (AB.isSameDirection(AC) && AB.len() >= AC.len())
+                return AC;
+            else
+                return undefined;
+        }
+        let AD = vector_1.Vector.add(AC, CD);
+        if (AB.isParallel(AD) && AB.len() >= AD.len()) {
+            let da = AD.len();
+            let dc = da - CD.len();
+            if (dc >= 0)
+                return AD;
+            else
+                return new vector_1.Vector([0, 0]);
+        }
+        else {
+            return undefined;
+        }
+    }
+    else {
+        let x, y;
+        if ((0, math_1.abs)(AB.x) < 0.0001) {
+            y = AC.x / CD.x * -1;
+            x = (AC.y + CD.y * y) / AB.y;
+            return vector_1.Vector.multiply(x, AB);
+        }
+        if ((0, math_1.abs)(AB.y) < 0.0001) {
+            y = AC.y / CD.y * -1;
+            x = (AC.x + CD.x * y) / AB.x;
+            return vector_1.Vector.multiply(x, AB);
+        }
+        if ((0, math_1.abs)(CD.x) < 0.0001) {
+            x = AC.x / AB.x;
+            return vector_1.Vector.multiply(x, AB);
+        }
+        if ((0, math_1.abs)(CD.y) < 0.0001) {
+            x = AC.y / AB.y;
+            return vector_1.Vector.multiply(x, AB);
+        }
+        y = (AB.x * AC.y / AB.y - AC.x) / (CD.x - AB.x * CD.y / AB.y);
+        x = (AC.y + CD.y * y) / AB.y;
+        return vector_1.Vector.multiply(x, AB);
+    }
+}
+exports.crossing = crossing;

package/lib/utils/index.d.ts

@@ -4,3 +4,5 @@ export * as math from './math';
 export * from './nextTick';
 export * from './formatting';
 export * from './xml';
+export * from './vector';
+export * from './time';

package/lib/utils/index.js

@@ -33,3 +33,5 @@ exports.math = __importStar(require("./math"));
 __exportStar(require("./nextTick"), exports);
 __exportStar(require("./formatting"), exports);
 __exportStar(require("./xml"), exports);
+__exportStar(require("./vector"), exports);
+__exportStar(require("./time"), exports);

package/lib/utils/merge.js

@@ -4,6 +4,9 @@ exports.merge = void 0;
 function merge(base, data, depth = 0) {
     if (!base)
         return;
+    if (typeof (data) === 'object' && typeof (base) !== 'object') {
+        base = data;
+    }
     let key;
     for (key in data) {
         if (typeof (data[key]) === 'object' && depth < 4) {

package/lib/utils/time.d.ts

@@ -0,0 +1 @@
+export declare const parseTime: (time: any) => number;

package/lib/utils/time.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTime = void 0;
+const parseTime = (time) => {
+    const parts = time.split(':');
+    const seconds = Number(parts[2]) + Number(parts[1]) * 60 + Number(parts[0]) * 3600;
+    return seconds;
+};
+exports.parseTime = parseTime;

package/lib/utils/vector.d.ts

@@ -0,0 +1,23 @@
+export declare class Vector {
+    protected _class: string;
+    protected _x: number;
+    protected _y: number;
+    constructor(props: any);
+    get x(): number;
+    get y(): number;
+    eq(v: any): boolean;
+    equals(v: any): boolean;
+    isParallel(v: any): boolean;
+    isSameDirection(v: any): boolean;
+    add(v: any): this;
+    min(v: any): this;
+    multiply(v: any): number | this;
+    static add(v1: any, v2: any): Vector;
+    static min(v1: any, v2: any): Vector;
+    static multiply(v1: any, v2: any): any;
+    static eq(v1: any, v2: any): any;
+    static isParallel(v1: any, v2: any): any;
+    static isVector(v: any): boolean;
+    len(): number;
+    angle(): number;
+}

package/lib/utils/vector.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector = void 0;
+const math_1 = require("./math");
+const CLASS_VECTOR = 'vector';
+class Vector {
+    constructor(props) {
+        if (props === undefined) {
+            throw new Error("missing mandatory argument: props");
+        }
+        if (Array.isArray(props)) {
+            if (props.length < 2)
+                throw new Error("incorrect value of: props");
+            this._x = props[0];
+            this._y = props[1];
+        }
+        if (Vector.isVector(props)) {
+            this._x = props.x;
+            this._y = props.y;
+        }
+        if (props.coordinates) {
+            if (props.coordinates.x === undefined || props.coordinates.y === undefined)
+                throw new Error("incorrect value of: props.coordinates");
+            this._x = props.coordinates.x;
+            this._y = props.coordinates.y;
+        }
+        if (props.path) {
+            if (props.path.bearing === undefined || props.path.distance === undefined)
+                throw new Error("incorrect value of: props.path");
+            let d = props.path.distance;
+            let alpha = props.path.bearing;
+            this._x = d * (0, math_1.sin)(alpha);
+            this._y = d * (0, math_1.cos)(alpha);
+        }
+        this._class = CLASS_VECTOR;
+    }
+    get x() {
+        return this._x;
+    }
+    get y() {
+        return this._y;
+    }
+    eq(v) {
+        return this.equals(v);
+    }
+    equals(v) {
+        if (!Vector.isVector(v) && !Array.isArray(v))
+            return false;
+        if (Vector.isVector(v))
+            return (this._x === v.x && this._y === v.y);
+        else
+            return (this._x === v[0] && this._y === v[1]);
+    }
+    isParallel(v) {
+        if (!Vector.isVector(v) && !Array.isArray(v))
+            return false;
+        if (this.eq(v))
+            return true;
+        if (Vector.isVector(v)) {
+            if (this._x === 0 && v.x === 0)
+                return true;
+            if (this._y === 0 && v.y === 0)
+                return true;
+            return ((0, math_1.abs)(v.x / this._x - v.y / this._y) < 0.0001);
+        }
+        else {
+            if (v.length < 2)
+                return false;
+            if (this._x === 0 && v[0] === 0)
+                return true;
+            if (this._y === 0 && v[1] === 0)
+                return true;
+            return ((0, math_1.abs)(v[0] / this._x - v[1] / this._y) < 0.0001);
+        }
+    }
+    isSameDirection(v) {
+        if (!this.isParallel(v))
+            return false;
+        let v2 = v;
+        if (!Vector.isVector(v))
+            v2 = new Vector(v);
+        let bearer1 = this.angle();
+        let bearer2 = v2.angle();
+        return Math.sign(bearer1) === Math.sign(bearer2);
+    }
+    add(v) {
+        if (Array.isArray(v)) {
+            if (v.length > 0)
+                this._x = this._x + v[0];
+            if (v.length > 1)
+                this._y = this._y + v[1];
+        }
+        else if (Vector.isVector(v)) {
+            this._x = this._x + v.x;
+            this._y = this._y + v.y;
+        }
+        else {
+            throw new Error("invalid argument");
+        }
+        return this;
+    }
+    min(v) {
+        if (Array.isArray(v)) {
+            if (v.length > 0)
+                this._x = this._x - v[0];
+            if (v.length > 1)
+                this._y = this._y - v[1];
+        }
+        else if (Vector.isVector(v)) {
+            this._x = this._x - v.x;
+            this._y = this._y - v.y;
+        }
+        else {
+            throw new Error("invalid argument");
+        }
+        return this;
+    }
+    multiply(v) {
+        if (typeof v === 'number') {
+            this._x = v * this._x;
+            this._y = v * this._y;
+        }
+        else if (Array.isArray(v)) {
+            let res = 0;
+            if (v.length > 0)
+                res += (this._x * v[0]);
+            if (v.length > 1)
+                res += (this._y * v[1]);
+            return res;
+        }
+        else if (Vector.isVector(v)) {
+            return (this._x * v.x + this._y * v.y);
+        }
+        else {
+            throw new Error("invalid argument");
+        }
+        return this;
+    }
+    static add(v1, v2) {
+        let v = new Vector(v1);
+        v.add(v2);
+        return v;
+    }
+    static min(v1, v2) {
+        let v = new Vector(v1);
+        v.min(v2);
+        return v;
+    }
+    static multiply(v1, v2) {
+        if (typeof v1 === 'number') {
+            if (Vector.isVector(v2) || Array.isArray(v2)) {
+                let v = new Vector(v2);
+                return v.multiply(v1);
+            }
+            else {
+                throw new Error("invalid argument");
+            }
+        }
+        if (Vector.isVector(v1))
+            return v1.multiply(v2);
+        if (Array.isArray(v1)) {
+            let v = new Vector(v1);
+            return v.multiply(v2);
+        }
+        throw new Error("invalid argument");
+    }
+    static eq(v1, v2) {
+        if (v1 === undefined)
+            return false;
+        if (Vector.isVector(v1))
+            return v1.eq(v2);
+        if (Array.isArray(v1)) {
+            let v = new Vector(v1);
+            return v.eq(v2);
+        }
+        throw new Error("invalid argument");
+    }
+    static isParallel(v1, v2) {
+        if (v1 === undefined)
+            return false;
+        if (Vector.isVector(v1))
+            return v1.isParallel(v2);
+        if (Array.isArray(v1)) {
+            let v = new Vector(v1);
+            return v.isParallel(v2);
+        }
+        throw new Error("invalid argument");
+    }
+    static isVector(v) {
+        return (v !== undefined && typeof v === 'object' && v.x !== undefined && v.y !== undefined && v._class !== undefined && v._class === CLASS_VECTOR);
+    }
+    len() {
+        return Math.sqrt(this._x * this._x + this._y * this._y);
+    }
+    angle() {
+        if (this.len() === 0)
+            return undefined;
+        return (0, math_1.asin)(this._x / this.len());
+    }
+}
+exports.Vector = Vector;

package/lib/utils/xml.d.ts

@@ -2,6 +2,7 @@ export type JSONObject = string | number | boolean | {
     [x: string]: JSONObject;
 } | Array<JSONObject>;
 export declare const toXml: (obj: JSONObject) => string;
+export declare const removeUTFBom: (str: string) => string;
 export declare const parseXml: (str: string) => Promise<XmlJSON>;
 export declare class XmlJSON {
     private _json;

package/lib/utils/xml.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XmlJSON = exports.parseXml = exports.toXml = void 0;
+exports.XmlJSON = exports.parseXml = exports.removeUTFBom = exports.toXml = void 0;
 const xml2js_1 = require("xml2js");
 const toXml = (obj) => {
     const keys = Object.keys(obj);
@@ -22,9 +22,16 @@ const toXml = (obj) => {
     return xml;
 };
 exports.toXml = toXml;
+const removeUTFBom = (str) => {
+    while (str.charCodeAt(0) === 0 || str.charCodeAt(0) === 0xFEFF || str.charCodeAt(0) === 0xFFFD)
+        str = str.substring(1);
+    return str;
+};
+exports.removeUTFBom = removeUTFBom;
 const parseXml = (str) => __awaiter(void 0, void 0, void 0, function* () {
     return new Promise((resolve, reject) => {
-        (0, xml2js_1.parseString)(str, (err, result) => {
+        const cleanStr = (0, exports.removeUTFBom)(str);
+        (0, xml2js_1.parseString)(cleanStr, (err, result) => {
             if (err) {
                 return reject(err);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.3.19",
+  "version": "1.3.21",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.2.3",
+    "incyclist-devices": "^2.2.4",
     "promise.any": "^2.0.6",
     "tcx-builder": "^1.1.1",
     "uuid": "^9.0.0",