raain-model 2.6.7 → 2.6.10

package/specs/quality/QualityPointEdgeCases.spec.ts

@@ -0,0 +1,215 @@
+import {expect} from 'chai';
+import {CartesianValue, QualityPoint, RainComputationQuality, SpeedMatrix, SpeedMatrixContainer} from '../../src';
+
+describe('QualityPoint Edge Cases', () => {
+    it('should handle missing or invalid data in quality points', () => {
+        // Test with missing gauge value
+        const qualityPointMissingGauge = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: new Date(),
+            rainDate: new Date(),
+            gaugeCartesianValue: null,
+            rainCartesianValues: [new CartesianValue({value: 10, lat: 1, lng: 1})],
+            speed: {x: 1, y: 1},
+            remark: 'missing gauge'
+        });
+
+        expect(qualityPointMissingGauge.getGaugeValue()).eq(undefined);
+        expect(qualityPointMissingGauge.getRainValue()).eq(10);
+        expect(qualityPointMissingGauge.getDelta()).eq(undefined);
+
+        // Test with missing rain values
+        const qualityPointMissingRain = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: new Date(),
+            rainDate: new Date(),
+            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 1}),
+            rainCartesianValues: [],
+            speed: {x: 1, y: 1},
+            remark: 'missing rain'
+        });
+
+        expect(qualityPointMissingRain.getGaugeValue()).eq(10);
+        expect(qualityPointMissingRain.getRainValue()).eq(0);
+        expect(qualityPointMissingRain.getDelta()).eq(10);
+
+        // Test with null dates
+        const qualityPointNullDates = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: null,
+            rainDate: null,
+            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 1}),
+            rainCartesianValues: [new CartesianValue({value: 10, lat: 1, lng: 1})],
+            speed: {x: 1, y: 1},
+            remark: 'null dates'
+        });
+
+        // Check that dates are set to Unix epoch when constructed with null
+        expect(qualityPointNullDates.gaugeDate.getTime()).to.equal(0);
+        expect(qualityPointNullDates.rainDate.getTime()).to.equal(0);
+        // getTimeDeltaInMinutes should return 0 for equal dates
+        expect(qualityPointNullDates.getTimeDeltaInMinutes()).to.equal(0);
+    });
+
+    it('should handle extreme value differences between gauge and rain', () => {
+        const qualityPointExtreme = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: new Date(),
+            rainDate: new Date(),
+            gaugeCartesianValue: new CartesianValue({value: 1000, lat: 1, lng: 1}),
+            rainCartesianValues: [new CartesianValue({value: 1, lat: 1, lng: 1})],
+            speed: {x: 1, y: 1},
+            remark: 'extreme difference'
+        });
+
+        expect(qualityPointExtreme.getGaugeValue()).eq(1000);
+        expect(qualityPointExtreme.getRainValue()).eq(1);
+        expect(qualityPointExtreme.getDelta()).eq(999);
+        expect(qualityPointExtreme.getRatio()).eq(0.001);
+    });
+
+    it('should handle multiple rain values with significant variance', () => {
+        const qualityPointMultiRain = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: new Date(),
+            rainDate: new Date(),
+            gaugeCartesianValue: new CartesianValue({value: 50, lat: 1, lng: 1}),
+            rainCartesianValues: [
+                new CartesianValue({value: 10, lat: 1, lng: 1}),
+                new CartesianValue({value: 20, lat: 1, lng: 1}),
+                new CartesianValue({value: 100, lat: 1, lng: 1})
+            ],
+            speed: {x: 1, y: 1},
+            remark: 'varied rain values'
+        });
+
+        expect(qualityPointMultiRain.getRainValue()).to.be.approximately(43.33, 0.01);
+        expect(qualityPointMultiRain.getDelta()).to.be.approximately(6.67, 0.01);
+    });
+});
+
+describe('SpeedMatrix Edge Cases', () => {
+    it('should handle empty quality points', () => {
+        const speedMatrix = new SpeedMatrix('test', '', []);
+        expect(speedMatrix.getQualityPoints().length).eq(0);
+        expect(speedMatrix.getMaxRain()).eq(-1);
+        expect(speedMatrix.getMaxGauge()).eq(-1);
+    });
+
+    it('should handle quality points with extreme speeds', () => {
+        const qualityPoint = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: new Date(),
+            rainDate: new Date(),
+            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 1}),
+            rainCartesianValues: [new CartesianValue({value: 10, lat: 1, lng: 1})],
+            speed: {x: 1000, y: 1000}, // Extreme speed
+            remark: 'extreme speed'
+        });
+
+        const speedMatrix = new SpeedMatrix('test', '', [qualityPoint]);
+        expect(speedMatrix.getQualityPoints().length).eq(1);
+        expect(SpeedMatrix.ComputeQualityIndicator(speedMatrix.getQualityPoints())).eq(0);
+    });
+});
+
+describe('SpeedMatrixContainer Quality Tests', () => {
+    it('should handle merging of conflicting matrices', () => {
+        const date1 = new Date();
+        const date2 = new Date(date1.getTime() + 1000); // 1 second later
+
+        const qualityPoint1 = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: date1,
+            rainDate: date1,
+            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 1}),
+            rainCartesianValues: [new CartesianValue({value: 10, lat: 1, lng: 1})],
+            speed: {x: 1, y: 1},
+            remark: 'first point'
+        });
+
+        const qualityPoint2 = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: date2,
+            rainDate: date2,
+            gaugeCartesianValue: new CartesianValue({value: 20, lat: 1, lng: 1}),
+            rainCartesianValues: [new CartesianValue({value: 20, lat: 1, lng: 1})],
+            speed: {x: -1, y: -1}, // Opposite direction
+            remark: 'second point'
+        });
+
+        const matrix1 = new SpeedMatrix('1', '', [qualityPoint1]);
+        const matrix2 = new SpeedMatrix('2', '', [qualityPoint2]);
+
+        const container = new SpeedMatrixContainer({matrices: [matrix1]});
+        container.merge(new SpeedMatrixContainer({matrices: [matrix2]}));
+
+        // Verify the merge result
+        expect(container.getQualityPoints().length).eq(2);
+        expect(container.getMaxGauge()).eq(20);
+        expect(container.getMaxRain()).eq(20);
+    });
+
+    it('should handle boundary conditions', () => {
+        const qualityPoint = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: new Date(),
+            rainDate: new Date(),
+            gaugeCartesianValue: new CartesianValue({value: 0, lat: 1, lng: 1}), // Zero gauge value
+            rainCartesianValues: [new CartesianValue({value: 0, lat: 1, lng: 1})], // Zero rain value
+            speed: {x: 0, y: 0}, // Zero speed
+            remark: 'boundary case'
+        });
+
+        const container = new SpeedMatrixContainer({matrices: [new SpeedMatrix('test', '', [qualityPoint])]});
+        expect(container.getMaxGauge()).eq(0);
+        expect(container.getMaxRain()).eq(0);
+    });
+});
+
+describe('RainComputationQuality Edge Cases', () => {
+    it('should handle quality computation with minimal data', () => {
+        const rainComputationQuality = new RainComputationQuality({
+            id: 'test',
+            date: new Date(),
+            isReady: true,
+            qualitySpeedMatrixContainer: new SpeedMatrixContainer({matrices: []})
+        });
+
+        expect(rainComputationQuality.isReady).eq(true);
+        expect(rainComputationQuality.qualitySpeedMatrixContainer.getQualityPoints().length).eq(0);
+    });
+
+    it('should handle quality computation with inconsistent data', () => {
+        const qualityPoint = new QualityPoint({
+            gaugeId: 'gauge1',
+            gaugeLabel: 'test gauge',
+            gaugeDate: new Date(),
+            rainDate: new Date(),
+            gaugeCartesianValue: new CartesianValue({value: 100, lat: 1, lng: 1}),
+            rainCartesianValues: [new CartesianValue({value: 1, lat: 1, lng: 1})], // Very different from gauge
+            speed: {x: 1, y: 1},
+            remark: 'inconsistent data'
+        });
+
+        const container = new SpeedMatrixContainer({matrices: [new SpeedMatrix('test', '', [qualityPoint])]});
+        const rainComputationQuality = new RainComputationQuality({
+            id: 'test',
+            date: new Date(),
+            isReady: true,
+            qualitySpeedMatrixContainer: container
+        });
+
+        expect(rainComputationQuality.isReady).eq(true);
+        expect(SpeedMatrix.ComputeQualityIndicator(rainComputationQuality.qualitySpeedMatrixContainer.getQualityPoints())).eq(99);
+    });
+});

package/specs/quality/QualityTools.spec.ts

@@ -0,0 +1,67 @@
+import {expect} from 'chai';
+import {CartesianTools, LatLng, Position, QualityTools} from '../../src';
+
+describe('QualityTools', () => {
+
+    it('should MapPositionToLatLng and MapLatLngToPosition', () => {
+
+        let point = new Position({x: 0, y: 0});
+        let latLng = QualityTools.MapPositionToLatLng(point);
+        expect(QualityTools.MapLatLngToPosition(latLng).x).eq(point.x);
+        expect(QualityTools.MapLatLngToPosition(latLng).y).eq(point.y);
+        expect(latLng.lat).eq(0);
+        expect(latLng.lng).eq(0);
+
+        point = new Position({x: 10, y: -10});
+        latLng = QualityTools.MapPositionToLatLng(point);
+        expect(QualityTools.MapLatLngToPosition(latLng).x).eq(point.x);
+        expect(QualityTools.MapLatLngToPosition(latLng).y).eq(point.y);
+        expect(latLng.lat).eq(-10);
+        expect(latLng.lng).eq(10);
+
+        point = new Position({x: 11.0003, y: -11.03});
+        latLng = QualityTools.MapPositionToLatLng(point);
+        expect(QualityTools.MapLatLngToPosition(latLng).x).eq(point.x);
+        expect(QualityTools.MapLatLngToPosition(latLng).y).eq(point.y);
+
+        point = new Position({x: 11.0003, y: -11.03});
+        const cartesianWidthDefault = new LatLng({lat: CartesianTools.DEFAULT_SCALE, lng: CartesianTools.DEFAULT_SCALE});
+        latLng = QualityTools.MapPositionToLatLng(point);
+        // expect(QualityTools.MapLatLngToPosition(latLng).x).eq(11);
+        expect(QualityTools.MapLatLngToPosition(latLng).y).eq(-11.03);
+
+        const cartesianWidth = new LatLng({lat: 0.01426, lng: 0.00898});
+        // expect(QualityTools.MapLatLngToPosition(latLng).y).eq(-11.02298);
+        // expect(QualityTools.MapLatLngToPosition(latLng).x).eq(11.0005);
+
+        latLng = new LatLng({lat: 48.86420972077865, lng: 2.2681507839189115});
+        // expect(QualityTools.MapLatLngToPosition(latLng).x).eq(2.27194);
+        // expect(QualityTools.MapLatLngToPosition(latLng).y).eq(48.86902);
+        latLng = new LatLng({lat: 48.86423959124331, lng: 2.254480156320581});
+        // expect(QualityTools.MapLatLngToPosition(latLng).x).eq(2.25398);
+        // expect(QualityTools.MapLatLngToPosition(latLng).y).eq(48.86902);
+
+    });
+
+    it('should CreateNDimArray', () => {
+        const createdEmptyNDimArray = QualityTools.CreateNDimArray([1, 2, 3]);
+        expect(createdEmptyNDimArray.length).eq(1);
+        expect(createdEmptyNDimArray[0].length).eq(2);
+        expect(createdEmptyNDimArray[0][1].length).eq(3);
+        expect(createdEmptyNDimArray[0][1][2]).eq(undefined);
+
+        const createdFilledNDimArray = QualityTools.CreateNDimArray([1, 2, 3], 4321);
+        expect(createdFilledNDimArray.length).eq(1);
+        expect(createdFilledNDimArray[0].length).eq(2);
+        expect(createdFilledNDimArray[0][1].length).eq(3);
+        expect(createdFilledNDimArray[0][1][2]).eq(4321);
+
+        const createdFilledWithZeroNDimArray = QualityTools.CreateNDimArray([1, 2, 3], 0);
+        expect(createdFilledWithZeroNDimArray[0][1][2]).eq(0);
+
+        const createdFilledWithAnyNDimArray = QualityTools.CreateNDimArray([1, 2, 3], []);
+        createdFilledWithAnyNDimArray[0][1][2].push('test');
+        expect(createdFilledWithAnyNDimArray[0][1][2][0]).eq('test');
+    });
+
+});

package/specs/quality/SpeedMatrix.spec.ts

@@ -0,0 +1,214 @@
+import {expect} from 'chai';
+import {CartesianTools, CartesianValue, Position, QualityPoint, RainComputationQuality, SpeedMatrix, SpeedMatrixContainer} from '../../src';
+
+describe('SpeedMatrix', () => {
+
+    const optionalTrace = (...log: any[]) => {
+        // console.log(new Date().toISOString(), log)
+    }
+    const optionalLogger = null; // console;
+
+    it('should SpeedMatrixContainer CreateFromJson, merge and renderMergedMatrix', () => {
+
+        const speedMatrices = [];
+        speedMatrices.push(new SpeedMatrix('1', '', []));
+        speedMatrices.push(new SpeedMatrix('2', '', []));
+        const speedMatrixContainer = new SpeedMatrixContainer({matrices: speedMatrices});
+
+        const speedMatrixContainerTwin = SpeedMatrixContainer.CreateFromJson(speedMatrixContainer.toJSON());
+        const optionsForFairCompare = {
+            removeFlatten: true,
+            removeMatrices: true,
+            removeIndicators: true,
+        };
+
+        expect(JSON.stringify(speedMatrixContainer.toJSON(optionsForFairCompare)))
+            .equal(JSON.stringify(speedMatrixContainerTwin.toJSON(optionsForFairCompare)));
+
+        const qualityPoint1 = new QualityPoint({
+            gaugeId: 'id1',
+            gaugeLabel: 'label1',
+            gaugeDate: null,
+            rainDate: null,
+            gaugeCartesianValue: new CartesianValue({value: 1, lat: 0, lng: 0}),
+            rainCartesianValues: [new CartesianValue({value: 2, lat: 0, lng: 0}), new CartesianValue({value: 3, lat: 0.01, lng: 0.02})],
+            speed: null,
+            remark: 'none',
+        });
+        const qualityPoint2 = new QualityPoint({
+            gaugeId: 'id2',
+            gaugeLabel: 'label2',
+            gaugeDate: null,
+            rainDate: null,
+            gaugeCartesianValue: new CartesianValue({value: 10, lat: 0, lng: 0}),
+            rainCartesianValues: [new CartesianValue({value: 20, lat: 0, lng: 0}), new CartesianValue({value: 30, lat: 0.01, lng: 0.02})],
+            speed: null,
+            remark: 'none',
+        });
+        const qualityPoints = [qualityPoint1, qualityPoint2];
+
+        const speedMatrixContainerToMerge = SpeedMatrixContainer.CreateFromJson({
+            matrices: [new SpeedMatrix('3', '', qualityPoints)],
+            trustedIndicator: 0.85
+        });
+        speedMatrixContainer.merge(speedMatrixContainerToMerge);
+
+        expect(speedMatrixContainer.getQualityPoints().length).eq(2);
+        expect(speedMatrixContainer.getQualityPoints('1').length).eq(0);
+        expect(speedMatrixContainer.getQualityPoints('2').length).eq(0);
+        expect(speedMatrixContainer.getQualityPoints('3').length).eq(2);
+        expect(speedMatrixContainer.getQualityPoints('3')[0].rainCartesianValues.length).eq(2);
+
+        expect(speedMatrixContainer.getQualityPointsByHistoricalPosition(0).length).eq(0);
+        expect(speedMatrixContainer.getQualityPointsByHistoricalPosition(2).length).eq(2);
+        expect(speedMatrixContainer.getQualityPointsByHistoricalPosition(20).length).eq(0);
+
+        const mergedMatrix = speedMatrixContainer.renderMergedMatrix();
+        expect(mergedMatrix.length).eq(Math.pow(SpeedMatrix.DEFAULT_MATRIX_RANGE * 2 + 1, 2));
+        expect(mergedMatrix[611].value).eq(1);
+        expect(mergedMatrix[611].x).eq(2);
+        expect(mergedMatrix[611].y).eq(1);
+        speedMatrixContainer.logMergedMatrix({normalize: false, logger: optionalLogger});
+        speedMatrixContainer.logMergedMatrix({normalize: true, logger: optionalLogger});
+    });
+
+    it('should SpeedMatrixContainer merge and compare', async () => {
+
+        const dateG1 = new Date(1.1 * 60 * 1000);
+        const dateG2 = new Date(7.1 * 60 * 1000);
+        const dateG3 = new Date(10.1 * 60 * 1000);
+        const dateR1 = new Date(2.1 * 60 * 1000);
+        const dateR2 = new Date(5.2 * 60 * 1000);
+        const dateR3 = new Date(8.2 * 60 * 1000);
+
+        const speed = {angleInDegrees: 1, pixelsPerPeriod: 2};
+        const qp = {
+            gaugeId: 'gaugeId1',
+            gaugeLabel: 'gaugeLabel',
+            gaugeDate: dateG1,
+            rainDate: dateR1,
+            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 2}),
+            rainCartesianValues: [new CartesianValue({value: 8, lat: 1, lng: 2}), new CartesianValue({value: 13, lat: 1.01, lng: 2.02})],
+            speed: {x: 1, y: 2},
+            remark: 'none',
+        };
+        const qualityPoint1 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
+        const qualityPoints1: QualityPoint[] = [qualityPoint1];
+        const roundScale: Position = new Position({x: CartesianTools.DEFAULT_SCALE, y: CartesianTools.DEFAULT_SCALE});
+
+        const flattenPositionRange = {xMin: -4, xMax: 4, yMin: -4, yMax: 4};
+        const speedMatrix1 = new SpeedMatrix('0', '', qualityPoints1, speed, 1, flattenPositionRange, roundScale);
+        const qualitySpeedMatrixContainer1 = new SpeedMatrixContainer({matrices: [speedMatrix1]});
+
+        // 1) Verify creation
+        qualitySpeedMatrixContainer1.logMergedMatrix({normalize: false, logger: optionalLogger});
+        speedMatrix1.logFlatten({logger: optionalLogger, simplify: false});
+        expect(qualitySpeedMatrixContainer1.getQuality()).eq(0.5);
+        expect(qualitySpeedMatrixContainer1.getMaxGauge()).eq(10);
+        expect(qualitySpeedMatrixContainer1.getMaxRain()).eq(10.5);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints().length).eq(1);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints()[0].getGaugeValue()).eq(10);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints()[0].getRainValue()).eq(10.5);
+        expect(qualityPoint1.getTimeDeltaInMinutes()).eq(1);
+
+        // Second and Third container to merge
+        qp.gaugeDate = dateG2;
+        const qualityPoint2_1 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
+        qp.gaugeId = 'gaugeId2';
+        const qualityPoint2_2 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
+        const qualityPoints2: QualityPoint[] = [qualityPoint2_1, qualityPoint2_2];
+        const speedMatrix2 = new SpeedMatrix('-2', '', qualityPoints2, speed, 1, flattenPositionRange, roundScale);
+        const qualitySpeedMatrixContainer2 = new SpeedMatrixContainer({matrices: [speedMatrix2]});
+        qualitySpeedMatrixContainer2.merge(qualitySpeedMatrixContainer1);
+
+        qp.gaugeId = 'gaugeId1';
+        qp.gaugeCartesianValue.value += 0.2;
+        qp.gaugeDate = dateG3;
+        const qualityPoint3_1 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
+        qp.gaugeId = 'gaugeId2';
+        qp.gaugeCartesianValue.value += 0.2;
+        qp.gaugeDate = dateG3;
+        const qualityPoint3_2 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
+        const qualityPoints3: QualityPoint[] = [qualityPoint3_1, qualityPoint3_2];
+        const speedMatrix3 = new SpeedMatrix('3', '', qualityPoints3, speed, 1, flattenPositionRange, roundScale);
+        const qualitySpeedMatrixContainer3 = new SpeedMatrixContainer({matrices: [speedMatrix3]});
+        qualitySpeedMatrixContainer2.merge(qualitySpeedMatrixContainer3);
+
+        // 2) Verify merging
+        qualitySpeedMatrixContainer2.logMergedMatrix({normalize: false, logger: optionalLogger});
+        expect(qualitySpeedMatrixContainer2.getQuality()).eq(0.38000000000000045);
+        expect(qualitySpeedMatrixContainer2.getMaxGauge()).eq(10.399999999999999);
+        expect(qualitySpeedMatrixContainer2.getMaxRain()).eq(10.5);
+        const qps = qualitySpeedMatrixContainer2.getQualityPoints();
+        expect(qps.length).eq(5);
+        expect(qps[0].getGaugeValue()).eq(10);
+        expect(qps[0].getRainValue()).eq(10.5);
+
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('0').length).eq(1);
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('0')[0].getGaugeValue()).eq(10);
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('0')[0].getRainValue()).eq(10.5);
+
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('-2').length).eq(2);
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('-2')[0].getGaugeValue()).eq(10);
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('-2')[0].getRainValue()).eq(10.5);
+
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('3').length).eq(2);
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('3')[0].getGaugeValue()).eq(10.2);
+        expect(qualitySpeedMatrixContainer2.getQualityPoints('3')[0].getRainValue()).eq(10.5);
+
+        // 3) Verify compare
+        const rainComputationQuality1 = new RainComputationQuality({
+            id: 'rcq1',
+            date: dateR1,
+            isReady: true,
+            qualitySpeedMatrixContainer: new SpeedMatrixContainer({matrices: [speedMatrix1, speedMatrix2]})
+        });
+        const rainComputationQuality2 = new RainComputationQuality({
+            id: 'rcq2',
+            date: dateR2,
+            isReady: true,
+            qualitySpeedMatrixContainer: qualitySpeedMatrixContainer2
+        });
+        const rainComputationQuality3 = new RainComputationQuality({
+            id: 'rcq3',
+            date: dateR3,
+            isReady: true,
+            qualitySpeedMatrixContainer: new SpeedMatrixContainer({matrices: [speedMatrix2, speedMatrix3]})
+        });
+        const compares = SpeedMatrixContainer.BuildCompares([rainComputationQuality1, rainComputationQuality2, rainComputationQuality3]);
+
+        // comparesPerDate
+        expect(compares.comparesPerDate.length).eq(3);
+        expect(compares.comparesPerDate[0].date.getTime()).eq(126000);
+        expect(compares.comparesPerDate[1].date.getTime()).eq(312000);
+        expect(compares.comparesPerDate[2].date.getTime()).eq(491999);
+        expect(compares.comparesPerDate[0].compareTimeline.length).eq(2);
+        expect(compares.comparesPerDate[1].compareTimeline.length).eq(3);
+        expect(compares.comparesPerDate[2].compareTimeline.length).eq(1);
+        expect(compares.comparesPerDate[0].compareTimeline[0].name).contains('in 2');
+        expect(compares.comparesPerDate[0].compareTimeline[1].name).contains('in 0');
+        expect(compares.comparesPerDate[1].compareTimeline[0].name).contains('in 2');
+        expect(compares.comparesPerDate[1].compareTimeline[1].name).contains('in 0');
+        expect(compares.comparesPerDate[1].compareTimeline[2].name).contains('since 3');
+        expect(compares.comparesPerDate[2].compareTimeline[0].name).contains('since 3');
+        expect(compares.comparesPerDate[0].compareTimeline[0].qualityPoints.length).eq(2);
+        expect(compares.comparesPerDate[0].compareTimeline[1].qualityPoints.length).eq(1);
+        expect(compares.comparesPerDate[1].compareTimeline[0].qualityPoints.length).eq(0);
+        expect(compares.comparesPerDate[1].compareTimeline[1].qualityPoints.length).eq(0);
+        expect(compares.comparesPerDate[1].compareTimeline[2].qualityPoints.length).eq(2);
+        expect(compares.comparesPerDate[2].compareTimeline[0].qualityPoints.length).eq(0);
+
+        // cumulative
+        expect(compares.compareCumulative.qualityPoints.length).eq(2);
+        expect(compares.compareCumulative.qualityPointsLegacy.length).eq(2);
+        expect(compares.compareCumulative.qualityPoints[0].gaugeId).eq('gaugeId2');
+        expect(compares.compareCumulative.qualityPoints[0].getGaugeValue()).eq(20.4);
+        expect(compares.compareCumulative.qualityPoints[0].getRainValue()).eq(21);
+        expect(compares.compareCumulative.qualityPoints[1].gaugeId).eq('gaugeId1');
+        expect(compares.compareCumulative.qualityPoints[1].getGaugeValue()).eq(30.2);
+        expect(compares.compareCumulative.qualityPoints[1].getRainValue()).eq(31.5);
+        expect(compares.compareCumulative.maxValue).eq(31.5);
+
+    });
+
+});

package/specs/radar/Radar.spec.ts

@@ -0,0 +1,129 @@
+import {expect} from 'chai';
+import {MeasureValuePolarContainer, PolarMeasureValue, RadarMeasure, RadarNode, RadarPolarMeasureValue, TeamNode} from '../../src';
+import {promisify} from 'util';
+
+const sleep = promisify(setTimeout);
+
+describe('Radar', () => {
+
+    const optionalTrace = (...log: any[]) => {
+        // console.log(new Date().toISOString(), log)
+    }
+
+    const optionalTable = (a: any[]) => {
+        // console.table(a)
+    }
+
+    it('should create ones', () => {
+        const team1 = new TeamNode({
+            id: 'tid1',
+            name: 'team1',
+            description: 'team...',
+            contracts: ['basic'],
+            contacts: []
+        });
+
+        const radarNode = new RadarNode({
+            id: 'RadarNode looks OK.', name: 'name', links: [],
+            latitude: 1, longitude: 1,
+            team: team1
+        });
+        expect(radarNode.id).eq('RadarNode looks OK.');
+        expect(JSON.stringify(radarNode.toJSON()))
+            .eq('{"id":"RadarNode looks OK.","links":[],"name":"name","latitude":1,"longitude":1,"team":"tid1"}');
+    });
+
+    it('should transform Polar', () => {
+
+        const measureValuePolarContainer = new MeasureValuePolarContainer({azimuth: 0, distance: 1, polarEdges: [33, 45.5]});
+        const polarMeasureValue = new PolarMeasureValue({
+            measureValuePolarContainers: [measureValuePolarContainer],
+            azimuthsCount: 720,
+            polarEdgesCount: 250
+        });
+        const radarPolarMeasureValue1 = new RadarPolarMeasureValue({polarMeasureValue, angle: 1, axis: 0});
+        expect(radarPolarMeasureValue1.getAzimuthsCount()).equal(720);
+        expect(radarPolarMeasureValue1.getPolarEdgesCount()).equal(250);
+
+        const radarPolarMeasureValue2 = new RadarPolarMeasureValue({polarMeasureValue: radarPolarMeasureValue1, angle: 1, axis: 0});
+        expect(radarPolarMeasureValue2.getAzimuthsCount()).equal(720);
+        expect(radarPolarMeasureValue2.getPolarEdgesCount()).equal(250);
+        expect(JSON.stringify(radarPolarMeasureValue2.toJSON({stringify: true})))
+            .eq(JSON.stringify(radarPolarMeasureValue1.toJSON({stringify: true})));
+        expect(JSON.stringify(radarPolarMeasureValue2.toJSON({stringify: true})))
+            .eq('{"polarMeasureValue":"{\\"measureValuePolarContainers\\":\\"[{\\\\\\"azimuth\\\\\\":0,\\\\\\"distance\\\\\\":1,\\\\\\"polarEdges\\\\\\":[33,45.5],\\\\\\"edgeOffset\\\\\\":0}]\\",\\"azimuthsCount\\":720,\\"polarEdgesCount\\":250}","angle":1,"axis":0}');
+
+        const radarPolarMeasureValue3 = new RadarPolarMeasureValue({
+            polarMeasureValue: radarPolarMeasureValue1.toJSONWithPolarStringified(),
+            angle: 1,
+            axis: 0
+        });
+        expect(radarPolarMeasureValue3.getAzimuthsCount()).equal(720);
+        expect(radarPolarMeasureValue3.getPolarEdgesCount()).equal(250);
+        expect(JSON.stringify(radarPolarMeasureValue3.toJSON({stringify: true})))
+            .eq(JSON.stringify(radarPolarMeasureValue1.toJSON({stringify: true})));
+        expect(JSON.stringify(radarPolarMeasureValue3.toJSON({stringify: true})))
+            .eq('{"polarMeasureValue":"{\\"measureValuePolarContainers\\":\\"[{\\\\\\"azimuth\\\\\\":0,\\\\\\"distance\\\\\\":1,\\\\\\"polarEdges\\\\\\":[33,45.5],\\\\\\"edgeOffset\\\\\\":0}]\\",\\"azimuthsCount\\":720,\\"polarEdgesCount\\":250}","angle":1,"axis":0}');
+
+        const radarMeasure = new RadarMeasure({id: 'measureId', values: [polarMeasureValue], date: new Date(100000)});
+        expect(JSON.stringify(radarMeasure.toJSON()))
+            .eq('{"id":"measureId","links":[],"date":"1970-01-01T00:01:40.000Z","validity":-1,"values":[{"measureValuePolarContainers":[{"azimuth":0,"distance":1,"polarEdges":[33,45.5],"edgeOffset":0}],"azimuthsCount":720,"polarEdgesCount":250}]}');
+
+        const polarMeasureValue1 = radarMeasure.values[0] as PolarMeasureValue;
+        const radarPolarMeasureValue4 = new RadarPolarMeasureValue({polarMeasureValue: polarMeasureValue1, angle: 1, axis: 0});
+        expect(JSON.stringify(radarPolarMeasureValue4.toJSON()))
+            .eq('{"polarMeasureValue":{"measureValuePolarContainers":[{"azimuth":0,"distance":1,"polarEdges":[33,45.5],"edgeOffset":0}],"azimuthsCount":720,"polarEdgesCount":250},"angle":1,"axis":0}');
+        expect(radarPolarMeasureValue4.getAzimuthsCount()).equal(720);
+        expect(radarPolarMeasureValue4.getPolarEdgesCount()).equal(250);
+
+        const radarPolarMeasureValue5 = new RadarPolarMeasureValue({
+            polarMeasureValue: JSON.stringify(radarMeasure.values[0]),
+            angle: 1, axis: 90
+        });
+        expect(radarPolarMeasureValue5.getAzimuthsCount()).equal(720);
+        expect(radarPolarMeasureValue5.getPolarEdgesCount()).equal(250);
+
+        const team1 = new TeamNode({
+            id: 'tid1',
+            name: 'team1',
+            description: 'team...',
+            contracts: ['basic'],
+            contacts: []
+        });
+        const radarNode = new RadarNode({
+            id: 'RadarNode looks OK.',
+            name: 'name',
+            links: [radarMeasure],
+            latitude: 1, longitude: 1,
+            team: team1
+        });
+
+        expect(JSON.stringify(radarNode.toJSON()))
+            .eq('{"id":"RadarNode looks OK.","links":[{"rel":"radar-measure","href":"../radar-measures/1970-01-01T00:01:40.000Z/measureId"}],"name":"name","latitude":1,"longitude":1,"team":"tid1"}');
+    });
+
+    it('should use multi-dimension image', async () => {
+
+        const testOneFake = (move: number) => {
+            const radarPolarMeasureValues = RadarPolarMeasureValue.BuildFakeRadarPolarMeasureValues(move);
+            expect(radarPolarMeasureValues.length).equal(6);
+            const polars = radarPolarMeasureValues[0].polarMeasureValue.getPolars();
+            expect(polars.length).equal(720);
+            expect(polars[0].polarEdges.length).equal(250);
+            optionalTable(polars
+                .filter((p, pi) => pi % 10 === 0)
+                .map(m =>
+                    m.polarEdges
+                        .filter((n, ni) => ni % 10 === 0)));
+        }
+
+        // for (let move = 0; move < 90; move++) {
+        testOneFake(0);
+        testOneFake(45);
+        testOneFake(90);
+        // await sleep(1000);
+        // }
+    });
+
+
+});