raain-model 2.6.8 → 2.6.10

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

@@ -1,9 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QualityPoint = void 0;
-const cartesian_1 = require("../cartesian");
-class QualityPoint {
-    constructor(json) {
+import {CartesianValue} from '../cartesian';
+
+export class QualityPoint {
+
+    public gaugeId: string;
+    public gaugeLabel: string;
+    public gaugeDate: Date;
+    public rainDate: Date;
+    public gaugeCartesianValue: CartesianValue;
+    public rainCartesianValues: CartesianValue[];
+    public speed: { x: number, y: number };
+    public remark: string;
+
+    constructor(json: {
+        gaugeId: string,
+        gaugeLabel: string,
+        gaugeDate: Date,
+        rainDate: Date,
+        gaugeCartesianValue: CartesianValue,
+        rainCartesianValues: CartesianValue[],
+        speed: { x: number, y: number },
+        remark: string,
+    }) {
         this.gaugeId = json.gaugeId;
         this.gaugeLabel = json.gaugeLabel;
         this.gaugeDate = new Date(json.gaugeDate);
@@ -13,68 +30,81 @@ class QualityPoint {
         this.speed = json.speed;
         this.remark = json.remark;
     }
-    static CreateFromJSON(src) {
-        var _a, _b;
+
+    static CreateFromJSON(src: QualityPoint) {
         return new QualityPoint({
             gaugeId: src.gaugeId,
             gaugeLabel: src.gaugeLabel,
             gaugeDate: new Date(src.gaugeDate),
             rainDate: new Date(src.rainDate),
-            gaugeCartesianValue: new cartesian_1.CartesianValue(src.gaugeCartesianValue),
-            rainCartesianValues: src.rainCartesianValues.map(v => new cartesian_1.CartesianValue(v)),
-            speed: { x: (_a = src.speed) === null || _a === void 0 ? void 0 : _a.x, y: (_b = src.speed) === null || _b === void 0 ? void 0 : _b.y },
+            gaugeCartesianValue: new CartesianValue(src.gaugeCartesianValue),
+            rainCartesianValues: src.rainCartesianValues.map(v => new CartesianValue(v)),
+            speed: {x: src.speed?.x, y: src.speed?.y},
             remark: src.remark,
-        });
+        })
     }
-    getGaugeValue() {
-        var _a;
-        return (_a = this.gaugeCartesianValue) === null || _a === void 0 ? void 0 : _a.value;
+
+    getGaugeValue(): number {
+        return this.gaugeCartesianValue?.value;
     }
-    getRainValue() {
+
+    getRainValue(): number {
         const sum = this.rainCartesianValues.reduce((prev, rcv) => prev + rcv.value, 0);
         return this.rainCartesianValues.length ? sum / this.rainCartesianValues.length : 0;
     }
-    getRainLat() {
-        var _a;
-        return (_a = this.getMiddleValue()) === null || _a === void 0 ? void 0 : _a.lat;
+
+    getRainLat(): number {
+        return this.getMiddleValue()?.lat;
     }
-    getRainLng() {
-        var _a;
-        return (_a = this.getMiddleValue()) === null || _a === void 0 ? void 0 : _a.lng;
+
+    getRainLng(): number {
+        return this.getMiddleValue()?.lng;
     }
-    getDelta() {
-        return Math.abs(this.getRainValue() - this.getGaugeValue());
+
+    getDelta(): number {
+        const rain = this.getRainValue();
+        const gauge = this.getGaugeValue();
+        if (typeof rain !== 'number' || typeof gauge !== 'number') {
+            return undefined;
+        }
+        return Math.abs(rain - gauge);
     }
-    getRatio() {
+
+    getRatio(): number {
+
         let ratio = 0;
         if (this.getRainValue() === 0) {
             return ratio;
         }
+
         if (this.getGaugeValue() > this.getRainValue()) {
             ratio = this.getRainValue() / this.getGaugeValue();
-        }
-        else {
+        } else {
             ratio = this.getGaugeValue() / this.getRainValue();
         }
+
         return ratio;
     }
-    getTimeDeltaInMinutes() {
+
+    getTimeDeltaInMinutes(): number {
         const delta = this.rainDate.getTime() - this.gaugeDate.getTime();
         return Math.round(delta / 60000);
     }
-    accumulateValues(qualityPoint) {
+
+    accumulateValues(qualityPoint: QualityPoint) {
         this.gaugeCartesianValue.value += qualityPoint.getGaugeValue();
         if (this.rainCartesianValues.length === 0) {
             this.rainCartesianValues = qualityPoint.rainCartesianValues.map(q => q);
-        }
-        else {
+        } else {
             this.rainCartesianValues.forEach(v => v.value += qualityPoint.getRainValue());
         }
     }
-    getMiddleValue() {
+
+    private getMiddleValue(): CartesianValue {
         if (!this.rainCartesianValues || this.rainCartesianValues.length === 0) {
             return null;
         }
+
         const sortedValues = this.rainCartesianValues.sort((a, b) => {
             return (a.lat - b.lat) * (a.lng - b.lng);
         });
@@ -82,5 +112,3 @@ class QualityPoint {
         return sortedValues[middlePos];
     }
 }
-exports.QualityPoint = QualityPoint;
-//# sourceMappingURL=QualityPoint.js.map

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

@@ -1,41 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpeedMatrix = void 0;
-const PositionHistory_1 = require("./history/PositionHistory");
-const PositionValue_1 = require("./position/PositionValue");
-const QualityTools_1 = require("./tools/QualityTools");
-const Position_1 = require("./position/Position");
-const QualityPoint_1 = require("./QualityPoint");
-const CartesianValue_1 = require("../cartesian/CartesianValue");
-const CartesianTools_1 = require("../cartesian/CartesianTools");
-class SpeedMatrix {
-    constructor(name, remarks, qualityPoints, speed = { angleInDegrees: 0, pixelsPerPeriod: 0 }, trustedTechnicalIndicator = SpeedMatrix.DEFAULT_TRUSTED_INDICATOR, flattenPositionRange = {
-        xMin: -SpeedMatrix.DEFAULT_MATRIX_RANGE,
-        xMax: SpeedMatrix.DEFAULT_MATRIX_RANGE,
-        yMin: -SpeedMatrix.DEFAULT_MATRIX_RANGE,
-        yMax: SpeedMatrix.DEFAULT_MATRIX_RANGE
-    }, roundScale = new Position_1.Position({ x: CartesianTools_1.CartesianTools.DEFAULT_SCALE, y: CartesianTools_1.CartesianTools.DEFAULT_SCALE })) {
-        this.name = name;
-        this.remarks = remarks;
-        this.qualityPoints = qualityPoints;
-        this.speed = speed;
-        this.trustedTechnicalIndicator = trustedTechnicalIndicator;
-        this.flattenPositionRange = flattenPositionRange;
-        this.roundScale = roundScale;
-    }
-    static CreateFromJson(json) {
-        const created = new SpeedMatrix(json.name, json.remarks, json.qualityPoints, json.speed, json.trustedTechnicalIndicator, json.flattenPositionRange, json.roundScale);
+import {PositionHistory} from './history/PositionHistory';
+import {PositionValue} from './position/PositionValue';
+import {QualityTools} from './tools/QualityTools';
+import {Position} from './position/Position';
+import {QualityPoint} from './QualityPoint';
+import {CartesianValue} from '../cartesian/CartesianValue';
+import {CartesianTools} from '../cartesian/CartesianTools';
+
+export class SpeedMatrix {
+
+    public static DEFAULT_MATRIX_RANGE = 16;
+    public static DEFAULT_TRUSTED_INDICATOR = 1;
+
+    protected flattenPositionHistory: number[][];
+
+    constructor(
+        public name: string,
+        public remarks: string,
+        protected qualityPoints: QualityPoint[],
+        protected speed: { angleInDegrees: number, pixelsPerPeriod: number } = {angleInDegrees: 0, pixelsPerPeriod: 0},
+        protected trustedTechnicalIndicator = SpeedMatrix.DEFAULT_TRUSTED_INDICATOR,
+        protected flattenPositionRange: { xMin: number, xMax: number, yMin: number, yMax: number } = {
+            xMin: -SpeedMatrix.DEFAULT_MATRIX_RANGE,
+            xMax: SpeedMatrix.DEFAULT_MATRIX_RANGE,
+            yMin: -SpeedMatrix.DEFAULT_MATRIX_RANGE,
+            yMax: SpeedMatrix.DEFAULT_MATRIX_RANGE
+        },
+        public roundScale: Position = new Position({x: CartesianTools.DEFAULT_SCALE, y: CartesianTools.DEFAULT_SCALE})
+    ) {
+    }
+
+    public static CreateFromJson(json: any | SpeedMatrix): SpeedMatrix {
+        const created = new SpeedMatrix(
+            json.name,
+            json.remarks,
+            json.qualityPoints,
+            json.speed,
+            json.trustedTechnicalIndicator,
+            json.flattenPositionRange,
+            json.roundScale);
+
         if (json.flattenPositionHistory) {
             created.flattenPositionHistory = json.flattenPositionHistory;
         }
+
         return created;
     }
+
     /**
      * Get quality indicator based on delta from computed vs reality
      *  0 is ideal
      *  2.56 (for example) is not ideal => can be improved :)
      */
-    static ComputeQualityIndicator(points) {
+    public static ComputeQualityIndicator(points: QualityPoint[]): number {
         let indicator = 0;
         for (const point of points) {
             indicator += point.getDelta();
@@ -43,34 +59,40 @@ class SpeedMatrix {
         if (points.length > 0) {
             indicator = indicator / points.length;
         }
+
         return indicator;
     }
-    static LogPositionValues(positionValues, valueDisplayFn, flattenPositionRange = {
-        xMin: -SpeedMatrix.DEFAULT_MATRIX_RANGE,
-        xMax: SpeedMatrix.DEFAULT_MATRIX_RANGE,
-        yMin: -SpeedMatrix.DEFAULT_MATRIX_RANGE,
-        yMax: SpeedMatrix.DEFAULT_MATRIX_RANGE
-    }, logger = console) {
-        const labelWithSign = (val) => {
+
+    static LogPositionValues(positionValues: PositionHistory[],
+                             valueDisplayFn: (v: PositionHistory) => string,
+                             flattenPositionRange: { xMin: number, xMax: number, yMin: number, yMax: number } = {
+                                 xMin: -SpeedMatrix.DEFAULT_MATRIX_RANGE,
+                                 xMax: SpeedMatrix.DEFAULT_MATRIX_RANGE,
+                                 yMin: -SpeedMatrix.DEFAULT_MATRIX_RANGE,
+                                 yMax: SpeedMatrix.DEFAULT_MATRIX_RANGE
+                             },
+                             logger = console) {
+
+        const labelWithSign = (val: number) => {
             if (val < 0) {
                 return '' + val;
-            }
-            else if (val === 0) {
+            } else if (val === 0) {
                 return ' ' + 0;
             }
             return '+' + val;
-        };
-        const labelX = (x) => {
+        }
+        const labelX = (x: number) => {
             return 'x' + labelWithSign(x - flattenPositionRange.xMax);
         };
-        const labelY = (y) => {
+        const labelY = (y: number) => {
             return 'y' + labelWithSign(y - flattenPositionRange.yMax);
         };
+
         const matrixToRender = {};
         for (let y = flattenPositionRange.yMax - flattenPositionRange.yMin; y >= 0; y--) {
             const xObject = {};
             for (let x = 0; x <= flattenPositionRange.xMax - flattenPositionRange.xMin; x++) {
-                xObject[labelX(x)] = valueDisplayFn(new PositionHistory_1.PositionHistory({
+                xObject[labelX(x)] = valueDisplayFn(new PositionHistory({
                     id: 'id',
                     label: 'label',
                     date: new Date(),
@@ -91,54 +113,65 @@ class SpeedMatrix {
                 matrixToRender[labelY(yOfMatrix)][labelX(xOfMatrix)] = valueDisplayFn(value);
             }
         }
-        logger === null || logger === void 0 ? void 0 : logger.table(matrixToRender);
+
+        logger?.table(matrixToRender);
     }
-    static Normalize(values) {
-        const built = [];
+
+
+    public static Normalize(values: PositionValue[]): PositionValue[] {
+        const built: PositionValue[] = [];
         let maxValue = Number.EPSILON;
         for (const pos of values) {
             maxValue = Math.max(maxValue, pos.value);
         }
         for (const pos of values) {
             const normalizedValue = pos.value / maxValue;
-            built.push(new PositionValue_1.PositionValue({ x: pos.x, y: pos.y, value: normalizedValue }));
+            built.push(new PositionValue({x: pos.x, y: pos.y, value: normalizedValue}));
         }
         return built;
     }
-    renderFlatten(options) {
+
+    renderFlatten(options: { normalize: boolean }): PositionValue[] {
+
         const positionMatrix = this.getFlatten();
         if (positionMatrix.length === 0) {
             return [];
         }
-        const positionHistories = [];
+
+        const positionHistories: PositionValue[] = [];
         let maxValue = 0;
         for (const [iX, posX] of positionMatrix.entries()) {
             for (const [iY, value] of posX.entries()) {
                 const x = iX + this.flattenPositionRange.xMin;
                 const y = iY + this.flattenPositionRange.yMin;
                 maxValue = Math.max(maxValue, value);
-                positionHistories.push(new PositionValue_1.PositionValue({ x, y, value }));
+                positionHistories.push(new PositionValue({x, y, value}));
             }
         }
+
         // Normalize
         if (maxValue && options.normalize) {
             positionHistories.forEach(p => {
                 p.value = p.value / maxValue;
             });
         }
+
         return positionHistories;
     }
-    getGaugeIdRelatedValues(id) {
+
+    getGaugeIdRelatedValues(id: string): QualityPoint {
         const points = this.qualityPoints.filter(p => p.gaugeId === id);
         if (points.length === 1) {
             return points[0];
         }
         return null;
     }
-    getQualityPoints() {
-        return this.qualityPoints.map(p => new QualityPoint_1.QualityPoint(p));
+
+    getQualityPoints(): QualityPoint[] {
+        return this.qualityPoints.map(p => new QualityPoint(p));
     }
-    getMaxRain() {
+
+    getMaxRain(): number {
         const qualityPoints = this.getQualityPoints();
         let max = -1;
         for (const p of qualityPoints) {
@@ -146,7 +179,8 @@ class SpeedMatrix {
         }
         return max;
     }
-    getMaxGauge() {
+
+    getMaxGauge(): number {
         const qualityPoints = this.getQualityPoints();
         let max = -1;
         for (const p of qualityPoints) {
@@ -154,12 +188,15 @@ class SpeedMatrix {
         }
         return max;
     }
-    getTrustedTechnicalIndicator() {
+
+    getTrustedTechnicalIndicator(): number {
         return this.trustedTechnicalIndicator;
     }
-    isConsistent() {
+
+    isConsistent(): boolean {
         return this.trustedTechnicalIndicator > SpeedMatrix.DEFAULT_TRUSTED_INDICATOR / 2;
     }
+
     toJSON() {
         return {
             name: this.name,
@@ -172,10 +209,13 @@ class SpeedMatrix {
             roundScale: this.roundScale,
         };
     }
-    logFlatten(options = { logger: console, simplify: false }) {
+
+    logFlatten(options: { logger: any, simplify: boolean }
+                   = {logger: console, simplify: false}) {
         const logger = options.logger;
-        const flatten = this.renderFlatten({ normalize: false });
-        const positionHistories = flatten.map(pv => new PositionHistory_1.PositionHistory({
+
+        const flatten = this.renderFlatten({normalize: false});
+        const positionHistories = flatten.map(pv => new PositionHistory({
             id: '-',
             label: '-',
             date: null,
@@ -185,63 +225,64 @@ class SpeedMatrix {
             valueFromGauge: -1,
             valueFromRain: -1
         }));
-        const valueDisplay = (pv) => {
+
+        const valueDisplay = (pv: PositionValue): string => {
             const v = pv.value;
             if (options.simplify) {
                 if (v === 1) {
                     return '##';
-                }
-                else if (v >= 0.8) {
+                } else if (v >= 0.8) {
                     return '#';
-                }
-                else if (v >= 0.5) {
+                } else if (v >= 0.5) {
                     return '=';
-                }
-                else if (v >= 0.2) {
+                } else if (v >= 0.2) {
                     return '_';
                 }
                 return ' ';
             }
             return '' + Math.round(v * 1000) / 1000;
-        };
+        }
+
         SpeedMatrix.LogPositionValues(positionHistories, valueDisplay, this.flattenPositionRange, logger);
     }
+
     getSpeed() {
         if (!this.speed) {
-            return { angleInDegrees: 0, pixelsPerPeriod: 0 };
+            return {angleInDegrees: 0, pixelsPerPeriod: 0};
         }
         return this.speed;
     }
-    getFlatten() {
+
+    protected getFlatten(): number[][] {
         if (this.flattenPositionHistory) {
             return this.flattenPositionHistory;
         }
+
         this.flattenPositionHistory = [];
         const yWidth = this.flattenPositionRange.yMax - this.flattenPositionRange.yMin + 1;
         const xWidth = this.flattenPositionRange.xMax - this.flattenPositionRange.xMin + 1;
         for (let y = 0; y < yWidth; y++) {
             this.flattenPositionHistory.push(new Array(xWidth).fill(0));
         }
+
         // same position => add value
         for (const qualityPoint of this.qualityPoints) {
             const value = qualityPoint.getRatio();
             const lat = qualityPoint.getRainLat() - qualityPoint.gaugeCartesianValue.lat;
             const lng = qualityPoint.getRainLng() - qualityPoint.gaugeCartesianValue.lng;
-            const cartesianValue = new CartesianValue_1.CartesianValue({ value, lat, lng });
-            const position = QualityTools_1.QualityTools.MapLatLngToPosition(cartesianValue);
+            const cartesianValue = new CartesianValue({value, lat, lng});
+            const position = QualityTools.MapLatLngToPosition(cartesianValue);
+
             const positionX = Math.round((position.x / this.roundScale.x) - this.flattenPositionRange.xMin);
             const positionY = Math.round((position.y / this.roundScale.y) - this.flattenPositionRange.yMin);
+
             if (0 <= positionX && positionX < xWidth && 0 <= positionY && positionY < yWidth) {
                 this.flattenPositionHistory[positionX][positionY] += cartesianValue.value;
-            }
-            else {
+            } else {
                 throw new Error('Matrix ranges and positions are not consistent.');
             }
         }
+
         return this.flattenPositionHistory;
     }
 }
-exports.SpeedMatrix = SpeedMatrix;
-SpeedMatrix.DEFAULT_MATRIX_RANGE = 16;
-SpeedMatrix.DEFAULT_TRUSTED_INDICATOR = 1;
-//# sourceMappingURL=SpeedMatrix.js.map