raain-model 1.10.25 → 1.11.4

package/{quality/SpeedMatrixContainer.js → src/quality/SpeedMatrixContainer.ts}

@@ -1,35 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpeedMatrixContainer = void 0;
-const SpeedMatrix_1 = require("./SpeedMatrix");
-const PositionValue_1 = require("./position/PositionValue");
-const PositionHistory_1 = require("./history/PositionHistory");
-const QualityPoint_1 = require("./QualityPoint");
-const CartesianValue_1 = require("../cartesian/CartesianValue");
-class SpeedMatrixContainer {
-    constructor(json) {
-        this.qualityPoints = undefined;
+import {SpeedMatrix} from './SpeedMatrix';
+import {PositionValue} from './position/PositionValue';
+import {PositionHistory} from './history/PositionHistory';
+import {QualityPoint} from './QualityPoint';
+import {CartesianValue} from '../cartesian/CartesianValue';
+
+export class SpeedMatrixContainer {
+
+    protected qualityPoints: any;
+    protected trustedIndicators: number[];
+    protected flattenMatrices: PositionValue[][];
+    protected matrices: SpeedMatrix[];
+
+    constructor(json: {
+        matrices: SpeedMatrix[]
+    }) {
+        this.qualityPoints = {};
         this.trustedIndicators = [];
         this.flattenMatrices = [];
         this.matrices = json.matrices;
     }
-    static CreateFromJson(json) {
-        const created = new SpeedMatrixContainer({ matrices: [] });
-        if (json === null || json === void 0 ? void 0 : json.qualityPoints) {
+
+    public static CreateFromJson(json: any): SpeedMatrixContainer {
+        const created = new SpeedMatrixContainer({matrices: []});
+        if (json?.qualityPoints) {
             created.qualityPoints = json.qualityPoints;
         }
-        if (json === null || json === void 0 ? void 0 : json.matrices) {
-            created.matrices = json.matrices.map((m) => SpeedMatrix_1.SpeedMatrix.CreateFromJson(m));
+        if (json?.matrices) {
+            created.matrices = json.matrices.map((m: any) => SpeedMatrix.CreateFromJson(m));
         }
-        if (json === null || json === void 0 ? void 0 : json.trustedIndicators) {
+        if (json?.trustedIndicators) {
             created.trustedIndicators = json.trustedIndicators;
         }
-        if (json === null || json === void 0 ? void 0 : json.flattenMatrices) {
+        if (json?.flattenMatrices) {
             created.flattenMatrices = json.flattenMatrices;
         }
         return created;
     }
-    static mergeStillComputed(v1, v2) {
+
+    protected static mergeStillComputed(v1: any, v2: any): any {
         if (!v1 && !v2) {
             return undefined;
         }
@@ -41,7 +49,8 @@ class SpeedMatrixContainer {
         }
         return null;
     }
-    static mergeDateMin(d1, d2) {
+
+    protected static mergeDateMin(d1: Date, d2: Date): Date {
         const stillComputed = this.mergeStillComputed(d1, d2);
         if (stillComputed === null) {
             return new Date(Math.min(new Date(d1).getTime(), new Date(d2).getTime()));
@@ -51,7 +60,8 @@ class SpeedMatrixContainer {
         }
         return stillComputed;
     }
-    static mergeDateMax(d1, d2) {
+
+    protected static mergeDateMax(d1: Date, d2: Date): Date {
         const stillComputed = this.mergeStillComputed(d1, d2);
         if (stillComputed === null) {
             return new Date(Math.max(new Date(d1).getTime(), new Date(d2).getTime()));
@@ -61,35 +71,41 @@ class SpeedMatrixContainer {
         }
         return stillComputed;
     }
-    static mergeAvg(v1, v2) {
+
+    protected static mergeAvg(v1: number, v2: number): number {
         if (v1 === 0 && v2 === 0) {
             return 0;
         }
+
         const stillComputed = this.mergeStillComputed(v1, v2);
         if (stillComputed === null) {
             return (v1 + v2) / 2;
         }
         return stillComputed;
     }
-    static mergeMin(v1, v2) {
+
+    protected static mergeMin(v1: number, v2: number): number {
         const stillComputed = this.mergeStillComputed(v1, v2);
         if (stillComputed === null) {
             return Math.min(v1, v2);
         }
         return stillComputed;
     }
-    static mergeConcat(a1, a2) {
+
+    protected static mergeConcat(a1: Array<any>, a2: Array<any>): Array<any> {
         const stillComputed = this.mergeStillComputed(a1, a2);
         if (stillComputed === null) {
             return a1.concat(a2);
         }
         return stillComputed;
     }
-    static mergeReduce(a1, a2) {
+
+    protected static mergeReduce(a1: Array<QualityPoint>, a2: Array<QualityPoint>): Array<QualityPoint> {
         const stillComputed = this.mergeStillComputed(a1, a2);
         if (stillComputed === null) {
+
             const ids = new Map();
-            const concatted = a1.concat(a2);
+            const concatted: QualityPoint[] = a1.concat(a2);
             for (const qualityPoint of concatted) {
                 const oldValue = {
                     gaugeValue: 0,
@@ -112,13 +128,14 @@ class SpeedMatrixContainer {
                     remark: qualityPoint.remark,
                 });
             }
+
             return [...ids].map(([id, value]) => {
-                return new QualityPoint_1.QualityPoint({
+                return new QualityPoint({
                     gaugeId: id,
                     gaugeLabel: value.gaugeLabel,
                     gaugeDate: value.gaugeDate,
                     rainDate: value.rainDate,
-                    gaugeCartesianValue: new CartesianValue_1.CartesianValue({ value: value.gaugeValue, lat: value.gaugeLat, lng: value.gaugeLng }),
+                    gaugeCartesianValue: new CartesianValue({value: value.gaugeValue, lat: value.gaugeLat, lng: value.gaugeLng}),
                     rainCartesianValues: value.rainCartesianValues,
                     speed: null,
                     remark: value.remark,
@@ -127,35 +144,54 @@ class SpeedMatrixContainer {
         }
         return stillComputed;
     }
+
     getMatrix(index = 0) {
-        return this.getMatrices()[index];
+        if (this.matrices.length <= index) {
+            return null;
+        }
+        return this.matrices[index];
+    }
+
+    getMatrixByName(name: string) {
+        const found = this.matrices.filter(m => m.name === name);
+        if (found.length === 1) {
+            return found[0];
+        }
+        return null;
     }
-    getMatrices() {
+
+    getMatrices(): SpeedMatrix[] {
         return this.matrices;
     }
-    getQualityPoints() {
-        if (this.qualityPoints) {
-            if (this.qualityPoints.length > 0 && this.flattenMatrices.length > 0) {
-                return this.qualityPoints.map(p => new QualityPoint_1.QualityPoint(p));
-            }
-            else {
-                this.qualityPoints = [];
-            }
-        }
-        const flattenMatrices = [];
-        let qualityPoints = [];
-        for (const matrix of this.matrices) {
-            if (matrix.isConsistent()) {
-                flattenMatrices.push(matrix.renderFlatten({ normalize: true }));
-                qualityPoints = SpeedMatrixContainer.mergeReduce(qualityPoints, matrix.getQualityPoints());
-            }
-        }
+
+    getQualityPoints(matrixName?: string): QualityPoint[] {
+
+        if (this.matrices.length === 0) {
+            return [];
+        }
+
+        this.storeFlattenMatrices();
+
+        if (!matrixName) {
+            matrixName = this.matrices[0].name;
+        }
+
+        if (this.qualityPoints[matrixName]?.length > 0 && this.flattenMatrices.length > 0) {
+            return this.qualityPoints[matrixName];
+        }
+
+        let qualityPoints: QualityPoint[] = [];
+        const matricesWithSameName = this.matrices.filter(m => m.name === matrixName);
+        if (matricesWithSameName.length === 1) {
+            qualityPoints = matricesWithSameName[0].getQualityPoints().map(p => new QualityPoint(p));
+        }
+
         // store
-        this.flattenMatrices = flattenMatrices;
-        this.qualityPoints = qualityPoints.map(p => new QualityPoint_1.QualityPoint(p));
-        return this.qualityPoints;
+        this.qualityPoints[matrixName] = qualityPoints;
+        return qualityPoints;
     }
-    getMaxGauge() {
+
+    getMaxGauge(): number {
         const qualityPoints = this.getQualityPoints();
         let max = -1;
         for (const p of qualityPoints) {
@@ -163,7 +199,8 @@ class SpeedMatrixContainer {
         }
         return max;
     }
-    getMaxRain() {
+
+    getMaxRain(): number {
         const qualityPoints = this.getQualityPoints();
         let max = -1;
         for (const p of qualityPoints) {
@@ -171,75 +208,88 @@ class SpeedMatrixContainer {
         }
         return max;
     }
+
     /**
      * Get summed quality indicator (0 ideally)
      *  @link SpeedMatrix.ComputeQualityIndicator
      */
-    getQuality() {
+    getQuality(): number {
         const qualityPoints = this.getQualityPoints();
-        return SpeedMatrix_1.SpeedMatrix.ComputeQualityIndicator(qualityPoints);
+        return SpeedMatrix.ComputeQualityIndicator(qualityPoints);
     }
-    getTrustedIndicators() {
+
+    getTrustedIndicators(): number[] {
         if (this.trustedIndicators.length > 0) {
             return this.trustedIndicators;
         }
+
         this.trustedIndicators = [];
         for (const matrix of this.matrices) {
             this.trustedIndicators.push(matrix.getTrustedTechnicalIndicator());
         }
+
         return this.trustedIndicators;
     }
-    getSpeed() {
-        let mergedSpeed;
+
+    getSpeed(): { angleInDegrees: number, pixelsPerPeriod: number } {
+        let mergedSpeed: { angleInDegrees: number, pixelsPerPeriod: number };
+
         for (const matrix of this.matrices) {
             if (!mergedSpeed) {
                 mergedSpeed = matrix.getSpeed();
-            }
-            else {
+            } else {
                 mergedSpeed = {
                     angleInDegrees: SpeedMatrixContainer.mergeAvg(mergedSpeed.angleInDegrees, matrix.getSpeed().angleInDegrees),
                     pixelsPerPeriod: SpeedMatrixContainer.mergeAvg(mergedSpeed.pixelsPerPeriod, matrix.getSpeed().pixelsPerPeriod),
-                };
+                }
             }
         }
+
         if (!mergedSpeed) {
-            mergedSpeed = { angleInDegrees: 0, pixelsPerPeriod: 0 };
+            mergedSpeed = {angleInDegrees: 0, pixelsPerPeriod: 0};
         }
+
         return mergedSpeed;
     }
-    isConsistent() {
+
+    isConsistent(): boolean {
         const indics = this.getTrustedIndicators();
         let indicAverage = 0;
         for (const indic of indics) {
             indicAverage += indic;
         }
         indicAverage = indicAverage / (indics.length ? indics.length : 1);
-        return indicAverage > (SpeedMatrix_1.SpeedMatrix.DEFAULT_TRUSTED_INDICATOR / 2);
+        return indicAverage > (SpeedMatrix.DEFAULT_TRUSTED_INDICATOR / 2);
     }
-    getFlattenMatrixCount() {
+
+    getFlattenMatrixCount(): number {
         return this.flattenMatrices.length;
     }
-    renderFlattenMatrix(index = 0, options = { normalize: true }) {
-        let rendered;
+
+    renderFlattenMatrix(index = 0,
+                        options: { normalize?: boolean } = {normalize: true}): PositionValue[] {
+
+        let rendered: PositionValue[];
         if (this.flattenMatrices && this.flattenMatrices[index]) {
             rendered = this.flattenMatrices[index];
-        }
-        else {
+        } else {
             this.getQualityPoints();
             rendered = this.flattenMatrices[index];
         }
+
         if (options.normalize) {
-            rendered = SpeedMatrix_1.SpeedMatrix.Normalize(rendered);
+            rendered = SpeedMatrix.Normalize(rendered);
         }
+
         return rendered;
     }
-    renderMergedMatrix(options = { normalize: true }) {
-        var _a;
+
+    renderMergedMatrix(options: { normalize?: boolean } = {normalize: true}): PositionValue[] {
         const count = this.flattenMatrices.length;
-        const size = Math.sqrt((_a = this.flattenMatrices[0]) === null || _a === void 0 ? void 0 : _a.length);
+        const size = Math.sqrt(this.flattenMatrices[0]?.length);
         const range = (size - 1) / 2;
         let maxValue = 0;
-        let matrix = [];
+        let matrix: PositionValue[] = [];
         for (let x = -range; x <= range; x++) {
             for (let y = -range; y <= range; y++) {
                 let value = 0;
@@ -249,15 +299,22 @@ class SpeedMatrixContainer {
                     maxValue = Math.max(maxValue, value);
                 }
                 value = value / count;
-                matrix.push(new PositionValue_1.PositionValue({ x, y, value }));
+                matrix.push(new PositionValue({x, y, value}));
             }
         }
+
         if (options.normalize) {
-            matrix = SpeedMatrix_1.SpeedMatrix.Normalize(matrix);
+            matrix = SpeedMatrix.Normalize(matrix);
         }
+
         return matrix;
     }
-    toJSON(options) {
+
+    toJSON(options?: {
+        removeFlatten?: boolean,
+        removeMatrices?: boolean,
+        removeIndicators?: boolean,
+    }) {
         const json = {
             qualityPoints: this.getQualityPoints(),
             trustedIndicators: this.getTrustedIndicators(),
@@ -267,27 +324,40 @@ class SpeedMatrixContainer {
                 .filter(m => !!m)
                 .map(m => m.toJSON()),
         };
-        if (options === null || options === void 0 ? void 0 : options.removeMatrices) {
+
+        if (options?.removeMatrices) {
             delete json.matrices;
         }
-        if (options === null || options === void 0 ? void 0 : options.removeFlatten) {
+
+        if (options?.removeFlatten) {
             delete json.flattenMatrices;
         }
-        if (options === null || options === void 0 ? void 0 : options.removeIndicators) {
+
+        if (options?.removeIndicators) {
             delete json.trustedIndicators;
         }
+
         return json;
     }
-    merge(speedMatrixContainerToMergeIn) {
-        this.qualityPoints = SpeedMatrixContainer.mergeReduce(this.getQualityPoints(), speedMatrixContainerToMergeIn.getQualityPoints());
-        this.trustedIndicators = SpeedMatrixContainer.mergeConcat(this.getTrustedIndicators(), speedMatrixContainerToMergeIn.getTrustedIndicators());
-        this.matrices = SpeedMatrixContainer.mergeConcat(this.matrices, speedMatrixContainerToMergeIn.matrices);
-        this.flattenMatrices = SpeedMatrixContainer.mergeConcat(this.flattenMatrices, speedMatrixContainerToMergeIn.flattenMatrices);
+
+    merge(speedMatrixContainerToMergeIn: SpeedMatrixContainer) {
+
+        // this.qualityPoints = SpeedMatrixContainer.mergeReduce(this.getQualityPoints(),
+        //    speedMatrixContainerToMergeIn.getQualityPoints());
+        this.trustedIndicators = SpeedMatrixContainer.mergeConcat(this.getTrustedIndicators(),
+            speedMatrixContainerToMergeIn.getTrustedIndicators());
+        this.matrices = SpeedMatrixContainer.mergeConcat(this.matrices,
+            speedMatrixContainerToMergeIn.matrices);
+        this.flattenMatrices = SpeedMatrixContainer.mergeConcat(this.flattenMatrices,
+            speedMatrixContainerToMergeIn.flattenMatrices);
+
         return this;
     }
-    logMergedMatrix(options = { normalize: true }) {
+
+    logMergedMatrix(options: { normalize?: boolean } = {normalize: true}) {
+
         const mergedMatrix = this.renderMergedMatrix(options);
-        const positionHistories = mergedMatrix.map(pv => new PositionHistory_1.PositionHistory({
+        const positionHistories = mergedMatrix.map(pv => new PositionHistory({
             id: '-',
             label: '-',
             date: null,
@@ -297,14 +367,31 @@ class SpeedMatrixContainer {
             valueFromGauge: -1,
             valueFromRain: -1
         }));
-        const valueDisplay = (pv) => {
+
+        const valueDisplay = (pv: PositionValue): string => {
             if (!pv) {
                 return '';
             }
             return '' + Math.round(pv.value * 1000) / 1000;
-        };
-        SpeedMatrix_1.SpeedMatrix.LogPositionValues(positionHistories, valueDisplay);
+        }
+
+        SpeedMatrix.LogPositionValues(positionHistories, valueDisplay);
+    }
+
+    protected storeFlattenMatrices() {
+
+        if (this.flattenMatrices.length === this.matrices.length) {
+            return this.flattenMatrices;
+        }
+
+        const flattenMatrices = [];
+        for (const matrix of this.matrices) {
+            if (matrix.isConsistent()) {
+                flattenMatrices.push(matrix.renderFlatten({normalize: true}));
+            }
+        }
+
+        this.flattenMatrices = flattenMatrices;
     }
+
 }
-exports.SpeedMatrixContainer = SpeedMatrixContainer;
-//# sourceMappingURL=SpeedMatrixContainer.js.map

package/src/quality/history/CartesianGaugeHistory.ts

@@ -0,0 +1,23 @@
+import {CartesianValue} from '../../cartesian/CartesianValue';
+
+export class CartesianGaugeHistory {
+    public gaugeId: string;
+    public gaugeLabel: string;
+    public date: Date;
+    public value: CartesianValue;
+    public configurationAsJSON: string;
+
+    constructor(json: {
+        gaugeId: string,
+        gaugeLabel: string,
+        date: Date,
+        value: CartesianValue,
+        configurationAsJSON: string,
+    }) {
+        this.gaugeId = json.gaugeId;
+        this.gaugeLabel = json.gaugeLabel;
+        this.date = json.date;
+        this.value = json.value;
+        this.configurationAsJSON = json.configurationAsJSON;
+    }
+}

package/src/quality/history/CartesianRainHistory.ts

@@ -0,0 +1,18 @@
+import {CartesianValue} from '../../cartesian/CartesianValue';
+
+export class CartesianRainHistory {
+
+    public periodBegin: Date;
+    public periodEnd: Date;
+    public computedValue: CartesianValue;
+
+    constructor(json: {
+        periodBegin: Date,
+        periodEnd: Date,
+        computedValue: CartesianValue
+    }) {
+        this.periodBegin = json.periodBegin;
+        this.periodEnd = json.periodEnd;
+        this.computedValue = json.computedValue;
+    }
+}

package/src/quality/history/PositionHistory.ts

@@ -0,0 +1,31 @@
+import {PositionValue} from '../position/PositionValue';
+
+export class PositionHistory extends PositionValue {
+    public id: string;
+    public label: string;
+    public date: Date;
+    public valueFromGauge: number;
+    public valueFromRain: number;
+    public configurationAsJSON: string;
+
+    constructor(json: {
+        id: string,
+        label: string,
+        date: Date,
+        x: number,
+        y: number,
+        value: number,
+        valueFromGauge?: number,
+        valueFromRain?: number,
+        configurationAsJSON?: string,
+    }) {
+        super(json);
+
+        this.id = json.id;
+        this.label = json.label;
+        this.date = json.date;
+        this.valueFromGauge = json.valueFromGauge;
+        this.valueFromRain = json.valueFromRain;
+        this.configurationAsJSON = json.configurationAsJSON;
+    }
+}

package/src/quality/position/Position.ts

@@ -0,0 +1,60 @@
+export class Position {
+    static DEFAULT_PRECISION = 6;
+    public x: number;
+    public y: number;
+    private readonly precision: number;
+
+    constructor(json: {
+        x: number,
+        y: number
+    }) {
+        this.x = json.x;
+        this.y = json.y;
+        this.precision = Position.DEFAULT_PRECISION;
+    }
+
+    static uniq = (a: Position[]): Position[] => {
+        const set = [];
+        for (const p of a) {
+            const same = set.filter(s => s.x === p.x && s.y === p.y);
+            if (same.length <= 0) {
+                set.push(p);
+            }
+        }
+        return set;
+    }
+
+    setPrecision(precision: number = Position.DEFAULT_PRECISION) {
+        const tenPower = Math.pow(10, precision);
+        const xy = this.getXY(precision);
+        this.x = xy.x;
+        this.y = xy.y;
+    }
+
+
+    getXY(precision?: number): { x: number, y: number } {
+        if (typeof precision === 'undefined') {
+            return {x: this.x, y: this.y};
+        }
+
+        const tenPower = Math.pow(10, precision);
+        return {
+            x: Math.round(this.x * tenPower) / tenPower,
+            y: Math.round(this.y * tenPower) / tenPower,
+        };
+    }
+
+    samePosition(p: Position, precision?: number) {
+        const xy = this.getXY(precision);
+        return xy.x === p.x && xy.y === p.y;
+    }
+
+    getPrecision(): number {
+        return this.precision;
+    }
+
+    getXYScaled(scale: number): { x: number, y: number } {
+        const precision = Math.round(Math.log10(1 / scale));
+        return this.getXY(precision);
+    }
+}

package/src/quality/position/PositionValue.ts

@@ -0,0 +1,15 @@
+import {Position} from '../position/Position';
+
+
+export class PositionValue extends Position {
+    public value: number;
+
+    constructor(json: {
+        x: number,
+        y: number,
+        value: number
+    }) {
+        super(json);
+        this.value = json.value;
+    }
+}