raain-model 2.6.8 → 2.6.10

package/{cartesian/CartesianTools.js → src/cartesian/CartesianTools.ts}

@@ -1,18 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CartesianTools = void 0;
-const LatLng_1 = require("./LatLng");
-class CartesianTools {
-    constructor(scale = CartesianTools.DEFAULT_SCALE, earthMap = undefined) {
-        this.scale = scale;
-        this.earthMap = earthMap;
+import {LatLng} from './LatLng';
+import {CartesianValue} from './CartesianValue';
+import {EarthMap} from './EarthMap';
+
+export class CartesianTools {
+
+    // scale of Pixel regarding LatLng : Approx. 1 => 100km, 0.01 => 1km, 0.005 => 500m
+    public static DEFAULT_SCALE = 0.01;
+
+    constructor(public scale = CartesianTools.DEFAULT_SCALE,
+                public earthMap: EarthMap = undefined) {
     }
-    static RoundLatLng(latOrLng, scale = CartesianTools.DEFAULT_SCALE, needPrecision = false) {
+
+    public static RoundLatLng(latOrLng: number, scale = CartesianTools.DEFAULT_SCALE, needPrecision = false): number {
+
         const result = Math.round(latOrLng / scale) * scale;
         if (!needPrecision) {
             return result;
         }
         return parseFloat(parseFloat('' + result).toPrecision(12));
+
         // alternative ?
         // let decimalPlaces = 0;
         // if (('' + scale).indexOf('0.') === 0) {
@@ -24,20 +30,27 @@ class CartesianTools {
         // const n = (latOrLng * p) * (1 + Number.EPSILON);
         // return Math.round(n) / p;
     }
-    static CreateLatLng(latLng) {
-        const created = new LatLng_1.LatLng(latLng);
+
+    public static CreateLatLng(latLng: { lat: number, lng: number }) {
+        const created = new LatLng(latLng);
         created.setPrecision();
         return created;
     }
-    static LimitWithPrecision(latOrLng, precision = 12) {
+
+    public static LimitWithPrecision(latOrLng: number, precision = 12): number {
         return parseFloat(parseFloat('' + latOrLng).toPrecision(precision));
     }
-    static IsEqualsLatLng(latOrLng1, latOrLng2, cartesianStep = CartesianTools.DEFAULT_SCALE) {
+
+    public static IsEqualsLatLng(latOrLng1: number, latOrLng2: number, cartesianStep = CartesianTools.DEFAULT_SCALE): boolean {
         return CartesianTools.RoundLatLng(latOrLng1, cartesianStep, true) === CartesianTools.RoundLatLng(latOrLng2, cartesianStep, true);
     }
-    static IsAroundLatLng(latLngCenter, latLngAround, stepRange, cartesianStep = CartesianTools.DEFAULT_SCALE) {
+
+    public static IsAroundLatLng(latLngCenter: LatLng, latLngAround: LatLng, stepRange: number,
+                                 cartesianStep = CartesianTools.DEFAULT_SCALE): boolean {
+
         let isAround = false;
-        const min = -stepRange * cartesianStep, max = stepRange * cartesianStep;
+        const min = -stepRange * cartesianStep,
+            max = stepRange * cartesianStep;
         for (let lat = min; !isAround && lat <= max; lat += cartesianStep) {
             for (let lng = min; !isAround && lng <= max; lng += cartesianStep) {
                 isAround = CartesianTools.RoundLatLng(latLngCenter.lat, cartesianStep, true)
@@ -48,54 +61,70 @@ class CartesianTools {
                 }
             }
         }
+
         return isAround;
     }
-    static IsNotAroundLatLng(latLngCenter, latLngAround, stepRange, cartesianStep = CartesianTools.DEFAULT_SCALE) {
+
+    public static IsNotAroundLatLng(latLngCenter: LatLng, latLngAround: LatLng, stepRange: number,
+                                    cartesianStep = CartesianTools.DEFAULT_SCALE): boolean {
+
         const max = (stepRange * cartesianStep) + Number.EPSILON;
+
         let isOut = CartesianTools.RoundLatLng(latLngCenter.lat, cartesianStep)
             > CartesianTools.RoundLatLng(latLngAround.lat + max, cartesianStep)
             || CartesianTools.RoundLatLng(latLngCenter.lat, cartesianStep)
-                < CartesianTools.RoundLatLng(latLngAround.lat - max, cartesianStep);
+            < CartesianTools.RoundLatLng(latLngAround.lat - max, cartesianStep);
         if (!isOut) {
             isOut = CartesianTools.RoundLatLng(latLngCenter.lng, cartesianStep)
                 > CartesianTools.RoundLatLng(latLngAround.lng + max, cartesianStep)
                 || CartesianTools.RoundLatLng(latLngCenter.lng, cartesianStep)
-                    < CartesianTools.RoundLatLng(latLngAround.lng - max, cartesianStep);
+                < CartesianTools.RoundLatLng(latLngAround.lng - max, cartesianStep);
         }
+
         return isOut;
     }
-    static DegToRad(azimuthInDegrees) {
+
+    public static DegToRad(azimuthInDegrees: number) {
         return azimuthInDegrees * Math.PI / 180;
     }
-    static GetAzimuthRad(angleInDegrees) {
+
+    public static GetAzimuthRad(angleInDegrees: number): number {
         return CartesianTools.DegToRad(-angleInDegrees + 90);
     }
-    static ComputeLatSteps(cartesianValues) {
+
+    public static ComputeLatSteps(cartesianValues: CartesianValue[]): number[] {
         const lats = cartesianValues.map(c => c.lat).sort((a, b) => a - b);
         return CartesianTools.UniqNum(lats);
     }
-    static ComputeLngSteps(cartesianValues) {
+
+    public static ComputeLngSteps(cartesianValues: CartesianValue[]): number[] {
         const lngs = cartesianValues.map(c => c.lng).sort((a, b) => a - b);
         return CartesianTools.UniqNum(lngs);
     }
-    static LogCartesianValues(cartesianValues, logger = console) {
-        logger === null || logger === void 0 ? void 0 : logger.log('>> raain-quality ### logCartesianValues with', cartesianValues.length, CartesianTools.DEFAULT_SCALE, ' in progress...');
+
+    public static LogCartesianValues(cartesianValues: CartesianValue[],
+                                     logger = console) {
+        logger?.log('>> raain-quality ### logCartesianValues with', cartesianValues.length,
+            CartesianTools.DEFAULT_SCALE, ' in progress...');
         const pointsToShow = {};
         const latSteps = CartesianTools.ComputeLatSteps(cartesianValues);
         const lngSteps = CartesianTools.ComputeLngSteps(cartesianValues);
-        const labelX = (v) => {
-            return CartesianTools.LabelWithSign(v);
-        };
-        const labelY = (v) => {
-            return CartesianTools.LabelWithSign(v);
-        };
+
+        const labelX = (v: number) => {
+            return CartesianTools.LabelWithSign(v)
+        }
+        const labelY = (v: number) => {
+            return CartesianTools.LabelWithSign(v)
+        }
         const valueDisplay = (v) => {
             return '' + Math.round(v * 100) / 100;
-        };
+        }
+
         for (let lat of latSteps) {
             const xObject = {};
             for (let lng of lngSteps) {
-                const latLng = new LatLng_1.LatLng({ lat, lng });
+
+                const latLng = new LatLng({lat, lng});
                 latLng.setPrecision(12);
                 lat = latLng.lat;
                 lng = latLng.lng;
@@ -103,35 +132,44 @@ class CartesianTools {
             }
             pointsToShow[labelY(lat)] = xObject;
         }
+
         for (const [index, point] of cartesianValues.entries()) {
-            let value = valueDisplay(point.value);
+            let value = valueDisplay(point.value)
             if (pointsToShow[labelY(point.lat)][labelX(point.lng)] !== '0') {
                 value = '' + value + '?' + pointsToShow[labelY(point.lat)][labelX(point.lng)];
             }
+
             pointsToShow[labelY(point.lat)][labelX(point.lng)] = value;
         }
-        logger === null || logger === void 0 ? void 0 : logger.table(pointsToShow);
+
+        logger?.table(pointsToShow);
     }
-    static UniqNum(a) {
+
+    public static UniqNum(a: number[]) {
         return [...new Set(a)];
     }
-    static UniqStr(a) {
+
+    public static UniqStr(a: number[]) {
         return [...new Set(a)];
     }
-    static GetDistanceFromLatLngInKm(latLng1, latLng2) {
+
+    public static GetDistanceFromLatLngInKm(latLng1: LatLng, latLng2: LatLng) {
         const R = 6371; // Radius of the earth in km
         const dLat = CartesianTools.DegToRad(latLng2.lat - latLng1.lat);
         const dLon = CartesianTools.DegToRad(latLng2.lng - latLng1.lng);
-        const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        const a =
+            Math.sin(dLat / 2) * Math.sin(dLat / 2) +
             Math.cos(CartesianTools.DegToRad(latLng1.lat)) * Math.cos(CartesianTools.DegToRad(latLng2.lat)) *
-                Math.sin(dLon / 2) * Math.sin(dLon / 2);
+            Math.sin(dLon / 2) * Math.sin(dLon / 2);
         const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
         return R * c; // Distance in km
     }
-    static VincentyDistance(latLng1, latLng2) {
+
+    public static VincentyDistance(latLng1: LatLng, latLng2: LatLng) {
         const a = 6378137.0; // WGS84 ellipsoid semi-major axis
         const f = 1 / 298.257223563; // WGS84 ellipsoid flattening
         const b = 6356752.314245; // derived semi-minor axis
+
         const L = CartesianTools.DegToRad(latLng2.lng - latLng1.lng);
         const U1 = Math.atan((1 - f) * Math.tan(CartesianTools.DegToRad(latLng1.lat)));
         const U2 = Math.atan((1 - f) * Math.tan(CartesianTools.DegToRad(latLng2.lat)));
@@ -139,103 +177,129 @@ class CartesianTools {
         const cosU1 = Math.cos(U1);
         const sinU2 = Math.sin(U2);
         const cosU2 = Math.cos(U2);
+
         let lambda = L;
-        let lambdaP;
+        let lambdaP: number;
         let iterLimit = 100;
-        let cosSqAlpha, sinSigma, cos2SigmaM, cosSigma, sigma, sinLambda, cosLambda, sinAlpha;
+        let cosSqAlpha: number, sinSigma: number, cos2SigmaM: number, cosSigma: number, sigma: number, sinLambda: number, cosLambda: number,
+            sinAlpha: number;
+
         do {
             sinLambda = Math.sin(lambda);
             cosLambda = Math.cos(lambda);
             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
+
+            if (sinSigma === 0) return 0; // co-incident points
+
             cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
             sigma = Math.atan2(sinSigma, cosSigma);
             sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
             cosSqAlpha = 1 - sinAlpha * sinAlpha;
             cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cosSqAlpha;
-            if (isNaN(cos2SigmaM))
-                cos2SigmaM = 0; // equatorial line
+
+            if (isNaN(cos2SigmaM)) cos2SigmaM = 0; // equatorial line
+
             const 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
+
+        if (iterLimit === 0) return NaN; // formula failed to converge
+
         const uSq = cosSqAlpha * (a * a - b * b) / (b * b);
         const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
         const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+
         const deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 *
             (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) -
                 B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+
         const s = b * A * (sigma - deltaSigma);
+
         return s / 1000; // distance in kilometers
     }
-    static LabelWithSign(val) {
+
+    protected static LabelWithSign(val: number) {
         const value = val;
         if (value < 0) {
             return '' + value;
-        }
-        else if (value === 0) {
+        } else if (value === 0) {
             return ' ' + 0;
         }
         return '+' + value;
     }
-    getScaleLatLng(latLng, latDirection = 1) {
+
+    public getScaleLatLng(latLng: LatLng, latDirection = 1): LatLng {
+
         let lat2 = latLng.lat + this.scale;
         if (latDirection < 0) {
             lat2 = latLng.lat - this.scale;
         }
-        const latDist = CartesianTools.VincentyDistance(new LatLng_1.LatLng({ lat: latLng.lat, lng: 0 }), new LatLng_1.LatLng({ lat: lat2, lng: 0 }));
+        const latDist = CartesianTools.VincentyDistance(new LatLng({lat: latLng.lat, lng: 0}),
+            new LatLng({lat: lat2, lng: 0}));
         let lngScale = this.scale;
-        let minDiff;
+        let minDiff: number;
         for (let scale = 0; scale <= this.scale * 100; scale += this.scale / 10) {
             scale = CartesianTools.LimitWithPrecision(scale);
-            const lngDist = CartesianTools.VincentyDistance(new LatLng_1.LatLng({ lat: lat2, lng: 0 }), new LatLng_1.LatLng({ lat: lat2, lng: scale }));
+            const lngDist = CartesianTools.VincentyDistance(new LatLng({lat: lat2, lng: 0}),
+                new LatLng({lat: lat2, lng: scale}));
             const diff2 = Math.abs(latDist - lngDist);
             if (!minDiff || Math.min(minDiff, diff2) === diff2) {
                 minDiff = diff2;
                 lngScale = scale;
-            }
-            else {
+            } else {
                 break;
             }
         }
+
         const lat = CartesianTools.LimitWithPrecision(this.scale);
         const lng = CartesianTools.LimitWithPrecision(lngScale);
-        return new LatLng_1.LatLng({ lat, lng });
+        return new LatLng({lat, lng});
     }
-    getScaleLatLngFromEarth(fromLatLng) {
+
+    public getScaleLatLngFromEarth(fromLatLng: LatLng): LatLng {
+
         if (!this.earthMap) {
             return null;
         }
+
         const posLat = Math.round((90 + fromLatLng.lat) / this.scale);
         const latitudeLongitudeScale = this.earthMap.latitudeLongitudeScales[posLat];
-        return new LatLng_1.LatLng({ lat: this.scale, lng: latitudeLongitudeScale });
+        return new LatLng({lat: this.scale, lng: latitudeLongitudeScale});
     }
-    getLatLngFromEarthMap(fromLatLng) {
+
+    public getLatLngFromEarthMap(fromLatLng: LatLng): LatLng {
+
         if (!this.earthMap) {
             return null;
         }
+
         const posLat = Math.round((90 + fromLatLng.lat) / this.scale);
         const lat = this.earthMap.latitudes[posLat];
         const latitudeLongitudeScale = this.earthMap.latitudeLongitudeScales[posLat];
+
         const lngPos = Math.round(fromLatLng.lng / latitudeLongitudeScale);
         const lng = CartesianTools.LimitWithPrecision(lngPos * latitudeLongitudeScale);
-        return new LatLng_1.LatLng({ lat, lng });
+
+        return new LatLng({lat, lng})
     }
-    buildLatLngEarthMap() {
+
+    public buildLatLngEarthMap(): EarthMap {
+
         if (this.earthMap) {
             delete this.earthMap;
         }
         this.earthMap = undefined;
-        const earthMap = {
+
+        const earthMap: EarthMap = {
             latitudes: [],
             latitudeScale: this.scale,
             latitudeLongitudeScales: []
         };
+
         for (let lat = -90; lat <= 90; lat += this.scale) {
             lat = CartesianTools.LimitWithPrecision(lat);
             earthMap.latitudes.push(lat);
@@ -243,13 +307,10 @@ class CartesianTools {
             if (lat > 0) {
                 direction = -1;
             }
-            earthMap.latitudeLongitudeScales.push(this.getScaleLatLng(new LatLng_1.LatLng({ lat, lng: 0 }), direction).lng);
+            earthMap.latitudeLongitudeScales.push(this.getScaleLatLng(new LatLng({lat, lng: 0}), direction).lng);
         }
+
         this.earthMap = earthMap;
         return earthMap;
     }
 }
-exports.CartesianTools = CartesianTools;
-// scale of Pixel regarding LatLng : Approx. 1 => 100km, 0.01 => 1km, 0.005 => 500m
-CartesianTools.DEFAULT_SCALE = 0.01;
-//# sourceMappingURL=CartesianTools.js.map

package/src/cartesian/CartesianValue.ts

@@ -0,0 +1,26 @@
+import {LatLng} from './LatLng';
+
+export class CartesianValue extends LatLng {
+
+    public value: number;
+
+    constructor(json: {
+                    value: number,
+                    lat: number,
+                    lng: number
+                }
+    ) {
+        super(json);
+        this.value = json.value;
+    }
+
+    toJSON(): {
+        value: number,
+        lat: number,
+        lng: number
+    } {
+        const json = super.toJSON() as any;
+        json.value = this.value;
+        return json;
+    }
+}

package/src/cartesian/EarthMap.ts

@@ -0,0 +1,5 @@
+export interface EarthMap {
+    latitudeScale: number,
+    latitudes: number[],
+    latitudeLongitudeScales: number[],
+}

package/src/cartesian/ICartesianMeasureValue.ts

@@ -0,0 +1,22 @@
+import {CartesianValue} from './CartesianValue';
+import {LatLng} from './LatLng';
+
+export interface ICartesianMeasureValue {
+
+    getLimitPoints(): [LatLng, LatLng];
+
+    getCartesianValuesStringified(): string;
+
+    getCartesianValues(): CartesianValue[];
+
+    toJSON(): any;
+
+    toJSONWithCartesianValuesStringified(): any;
+
+    getCartesianValue(json: { lat: number, lng: number }): CartesianValue;
+
+    getCartesianValueRounded(json: { lat: number, lng: number, scale: LatLng }): CartesianValue;
+
+    setCartesianValue(json: { lat: number, lng: number, value: number }): void;
+
+}

package/src/cartesian/LatLng.ts

@@ -0,0 +1,43 @@
+import {CartesianTools} from './CartesianTools';
+
+export class LatLng {
+
+    public lat: number;
+    public lng: number;
+
+    constructor(json: {
+        lat: number,
+        lng: number,
+    }) {
+        if (typeof json?.lat === 'undefined' || typeof json?.lng === 'undefined') {
+            throw new Error('LatLng needs valid latitude && longitude');
+        }
+
+        this.lat = json.lat;
+        this.lng = json.lng;
+    }
+
+    public equals(v: LatLng) {
+        return this.lat === v.lat && this.lng === v.lng;
+    }
+
+    setPrecision(precision: number = 12) {
+        const tenPower = Math.pow(10, precision);
+        this.lat = Math.round(this.lat * tenPower) / tenPower;
+        this.lng = Math.round(this.lng * tenPower) / tenPower;
+    }
+
+    rounded(scale: LatLng) {
+        this.lat = CartesianTools.RoundLatLng(this.lat, scale.lat, true);
+        this.lng = CartesianTools.RoundLatLng(this.lng, scale.lng, true);
+    }
+
+    limitPrecision(precision = 12) {
+        this.lat = CartesianTools.LimitWithPrecision(this.lat, precision);
+        this.lng = CartesianTools.LimitWithPrecision(this.lng, precision);
+    }
+
+    toJSON() {
+        return {lat: this.lat, lng: this.lng};
+    }
+}

package/src/cartesian/RadarCartesianMeasureValue.ts

@@ -0,0 +1,32 @@
+import {CartesianValue} from './CartesianValue';
+import {CartesianMeasureValue} from './CartesianMeasureValue';
+import {LatLng} from './LatLng';
+
+export class RadarCartesianMeasureValue extends CartesianMeasureValue {
+
+    public angle: number;   // In degrees. Radar incidence angle, from 0° to 90°, from the ground to the top
+    public axis: number;    // In degrees. Polarization angle 0° = horizontal, 90°= vertical.
+
+    constructor(json: {
+        cartesianValues: string | CartesianValue[],
+        angle: number,
+        axis: number,
+        limitPoints: [LatLng, LatLng],
+    }) {
+
+        super(json);
+        this.angle = json.angle;
+        this.axis = json.axis;
+    }
+
+    toJSON(options = {stringify: false}): any {
+        const json: any = super.toJSON(options);
+        json.angle = this.angle;
+        json.axis = this.axis;
+        return json;
+    }
+
+    toJSONWithCartesianValuesStringified(): any {
+        return this.toJSON({stringify: true});
+    }
+}

package/src/cartesian/RainCartesianMeasureValue.ts

@@ -0,0 +1,32 @@
+import {IVersion} from '../organization';
+import {CartesianValue} from './CartesianValue';
+import {CartesianMeasureValue} from './CartesianMeasureValue';
+import {LatLng} from './LatLng';
+
+export class RainCartesianMeasureValue extends CartesianMeasureValue implements IVersion {
+
+    private readonly version: string;
+
+    constructor(json: {
+        cartesianValues: string | CartesianValue[],
+        limitPoints: [LatLng, LatLng],
+        version: string,
+    }) {
+        super(json);
+        this.version = json.version;
+    }
+
+    getVersion(): string {
+        return this.version;
+    }
+
+    toJSON(options = {stringify: false}): any {
+        const json: any = super.toJSON(options);
+        json.version = this.getVersion();
+        return json;
+    }
+
+    toJSONWithCartesianValuesStringified(): any {
+        return this.toJSON({stringify: true});
+    }
+}

package/src/gauge/GaugeMeasure.ts

@@ -0,0 +1,42 @@
+import {Measure} from '../organization';
+import {IPolarMeasureValue} from '../polar';
+import {ICartesianMeasureValue} from '../cartesian';
+import {GaugeNode} from './GaugeNode';
+
+/**
+ *  api/gauges/:id/measures/:id
+ */
+export class GaugeMeasure extends Measure {
+
+    public static TYPE = 'gauge-measure';
+
+    public gauge: string;
+
+    constructor(json: {
+                    id: string,
+                    values: IPolarMeasureValue[] | ICartesianMeasureValue[] | number[],
+                    date?: Date,
+                    validity?: number,
+                    configurationAsJSON?: string,
+                    gauge?: string
+                }
+    ) {
+        super(json);
+        if (json.gauge) {
+            this.addLinks([new GaugeNode({id: json.gauge, latitude: NaN, longitude: NaN, team: null, name: null})]);
+        }
+    }
+
+    public toJSON(options?: any): any {
+        const json = super.toJSON(options);
+        const gaugeLink = this.getLink(GaugeNode.TYPE);
+        if (gaugeLink) {
+            json['gauge'] = gaugeLink.getId();
+        }
+        return json;
+    }
+
+    protected getLinkType(): string {
+        return GaugeMeasure.TYPE;
+    }
+}