raain-model 2.6.7 → 2.6.10

package/{polar/PolarMeasureValueMap.js → src/polar/PolarMeasureValueMap.ts}

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PolarMeasureValueMap = void 0;
-const MeasureValuePolarContainer_1 = require("./MeasureValuePolarContainer");
-const PolarValue_1 = require("./PolarValue");
-const PolarMeasureValue_1 = require("./PolarMeasureValue");
-const PolarFilter_1 = require("./PolarFilter");
+import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
+import {PolarValue} from './PolarValue';
+import {PolarMeasureValue} from './PolarMeasureValue';
+import {PolarFilter} from './PolarFilter';
+
+
 /**
  * PolarMeasureValue Map tools to optimize get/set
  */
-class PolarMeasureValueMap {
-    constructor(polarMeasureValue, buildPolarFilter = new PolarFilter_1.PolarFilter()) {
-        this.polarMeasureValue = polarMeasureValue;
-        this.buildPolarFilter = buildPolarFilter;
-        this.builtMeasureValuePolarContainers = [];
+export class PolarMeasureValueMap {
+
+    protected builtMeasureValuePolarContainers: MeasureValuePolarContainer[] = [];
+
+    constructor(public polarMeasureValue: PolarMeasureValue,
+                protected buildPolarFilter: PolarFilter = new PolarFilter()) {
         this.buildFromPolar();
     }
-    static UpdateIndex(arrayLength, index) {
+
+    protected static UpdateIndex(arrayLength: number, index: number): number {
         let newIndex = index;
         if (arrayLength <= index) {
             newIndex = index - arrayLength;
-        }
-        else if (index < 0) {
+        } else if (index < 0) {
             newIndex = arrayLength + index;
         }
         if (newIndex < 0) {
@@ -28,240 +28,319 @@ class PolarMeasureValueMap {
         }
         return Math.round(newIndex);
     }
+
     applyToPolar() {
-        const polarMeasureValue = new PolarMeasureValue_1.PolarMeasureValue({
+        const polarMeasureValue = new PolarMeasureValue({
             measureValuePolarContainers: this.builtMeasureValuePolarContainers,
             azimuthsCount: this.polarMeasureValue.getAzimuthsCount(),
             polarEdgesCount: this.polarMeasureValue.getPolarEdgesCount()
         });
-        const filteredPolarMeasureValue = polarMeasureValue.getFiltered({ nullValues: true, ordered: true });
-        this.polarMeasureValue.setPolarsAsContainer(filteredPolarMeasureValue.getPolars(), { resetCount: false });
+
+        const filteredPolarMeasureValue = polarMeasureValue.getFiltered({nullValues: true, ordered: true});
+
+        this.polarMeasureValue.setPolarsAsContainer(filteredPolarMeasureValue.getPolars(), {resetCount: false});
     }
-    duplicate(polarFilter) {
+
+    duplicate(polarFilter?: PolarFilter): PolarMeasureValueMap {
         const newPolarMeasureValueMap = new PolarMeasureValueMap(null);
         const measureValuePolarContainers = [];
         for (const measureValuePolarContainer of this.builtMeasureValuePolarContainers) {
-            const duplicateMeasureValuePolarContainer = measureValuePolarContainer.getFiltered({ nullValues: false });
+            const duplicateMeasureValuePolarContainer = measureValuePolarContainer.getFiltered({nullValues: false});
             measureValuePolarContainers.push(duplicateMeasureValuePolarContainer);
         }
+
         newPolarMeasureValueMap.polarMeasureValue = this.polarMeasureValue;
         newPolarMeasureValueMap.builtMeasureValuePolarContainers = measureValuePolarContainers;
         newPolarMeasureValueMap.buildPolarFilter = this.buildPolarFilter.merging();
         const newBuildPolarFilter = this.buildPolarFilter.merging(polarFilter);
+
         if (!newPolarMeasureValueMap.buildPolarFilter.equal(newBuildPolarFilter)) {
             newPolarMeasureValueMap.filter(newBuildPolarFilter);
         }
+
         return newPolarMeasureValueMap;
     }
-    getPolarValue(json) {
+
+    getPolarValue(json: { azimuthIndex: number, edgeIndex: number }): PolarValue {
         let edgeValue = 0;
         let distanceInMetersFound = 0;
-        const { azimuthIndex, azimuthInDegrees } = this.updatedAzimuth(json.azimuthIndex);
+        const {azimuthIndex, azimuthInDegrees} = this.updatedAzimuth(json.azimuthIndex);
         if (azimuthIndex >= 0) {
+
             if (azimuthIndex >= this.builtMeasureValuePolarContainers.length) {
                 // throw new Error('Impossible to getPolarValue azimuth from ' + JSON.stringify(json));
                 return null;
             }
+
             const measureValuePolarContainer = this.builtMeasureValuePolarContainers[azimuthIndex];
-            const { edgeIndex, distanceInMeters } = this.updatedEdge(json.edgeIndex, measureValuePolarContainer);
+            const {edgeIndex, distanceInMeters} = this.updatedEdge(json.edgeIndex, measureValuePolarContainer);
             distanceInMetersFound = distanceInMeters;
+
             if (edgeIndex >= 0) {
+
                 if (edgeIndex >= measureValuePolarContainer.polarEdges.length) {
                     // throw new Error('Impossible to getPolarValue edge from ' + JSON.stringify(json));
                     return null;
                 }
+
                 edgeValue = measureValuePolarContainer.polarEdges[edgeIndex];
             }
-        }
-        else {
-            const { distanceInMeters } = this.updatedEdge(json.edgeIndex);
+        } else {
+            const {distanceInMeters} = this.updatedEdge(json.edgeIndex);
             distanceInMetersFound = distanceInMeters;
         }
-        return new PolarValue_1.PolarValue({
+
+        return new PolarValue({
             value: edgeValue,
             polarAzimuthInDegrees: azimuthInDegrees,
             polarDistanceInMeters: distanceInMetersFound
         });
     }
-    setPolarValue(json) {
-        const { azimuthIndex, azimuthInDegrees } = this.updatedAzimuth(json.azimuthIndex);
+
+    setPolarValue(json: { azimuthIndex: number, edgeIndex: number, value: number }) {
+
+        const {azimuthIndex, azimuthInDegrees} = this.updatedAzimuth(json.azimuthIndex);
         if (azimuthIndex < 0) {
             throw new Error(`Impossible to set ${JSON.stringify(json)} in this optimized polar structure`);
         }
+
         const measureValuePolarContainer = this.builtMeasureValuePolarContainers[azimuthIndex];
-        const { edgeIndex } = this.updatedEdge(json.edgeIndex, measureValuePolarContainer);
+        const {edgeIndex} = this.updatedEdge(json.edgeIndex, measureValuePolarContainer);
         if (edgeIndex < 0) {
             throw new Error(`Impossible to set ${JSON.stringify(json)} in this optimized polar structure`);
         }
+
         measureValuePolarContainer.polarEdges[edgeIndex] = json.value;
     }
-    iterate(onEachValue, options) {
-        var _a, _b, _c, _d;
-        const azimuthMin = typeof ((_a = options === null || options === void 0 ? void 0 : options.polarFilter) === null || _a === void 0 ? void 0 : _a.azimuthMin) !== 'undefined' ? options === null || options === void 0 ? void 0 : options.polarFilter.azimuthMin : 0;
-        const azimuthMax = typeof ((_b = options === null || options === void 0 ? void 0 : options.polarFilter) === null || _b === void 0 ? void 0 : _b.azimuthMax) !== 'undefined' ? options === null || options === void 0 ? void 0 : options.polarFilter.azimuthMax
+
+    iterate(onEachValue: (
+                polarValue: PolarValue,
+                azimuthIndex: number,
+                edgeIndex: number,
+                valueSetter: (newValue: number) => void
+            ) => void,
+            options?: {
+                iterateOnEachEdge?: boolean,
+                polarFilter?: PolarFilter
+            }) {
+
+        const azimuthMin = typeof options?.polarFilter?.azimuthMin !== 'undefined' ? options?.polarFilter.azimuthMin : 0;
+        const azimuthMax = typeof options?.polarFilter?.azimuthMax !== 'undefined' ? options?.polarFilter.azimuthMax
             : this.polarMeasureValue.getAzimuthsCount();
-        const edgeMin = typeof ((_c = options === null || options === void 0 ? void 0 : options.polarFilter) === null || _c === void 0 ? void 0 : _c.edgeMin) !== 'undefined' ? options === null || options === void 0 ? void 0 : options.polarFilter.edgeMin : 0;
-        const edgeMax = typeof ((_d = options === null || options === void 0 ? void 0 : options.polarFilter) === null || _d === void 0 ? void 0 : _d.edgeMax) !== 'undefined' ? options === null || options === void 0 ? void 0 : options.polarFilter.edgeMax
+        const edgeMin = typeof options?.polarFilter?.edgeMin !== 'undefined' ? options?.polarFilter.edgeMin : 0;
+        const edgeMax = typeof options?.polarFilter?.edgeMax !== 'undefined' ? options?.polarFilter.edgeMax
             : this.polarMeasureValue.getPolarEdgesCount();
-        if (options === null || options === void 0 ? void 0 : options.iterateOnEachEdge) {
+
+        if (options?.iterateOnEachEdge) {
             this.iterateOnEachEdge(azimuthMin, azimuthMax, edgeMin, edgeMax, onEachValue);
-        }
-        else {
+        } else {
             this.iterateOnEachAzimuth(azimuthMin, azimuthMax, edgeMin, edgeMax, onEachValue);
         }
     }
+
     countPolar() {
         return this.builtMeasureValuePolarContainers
             .reduce((p, c) => p + c.getPolarEdgesCount(), 0);
     }
-    countPolarWithEdgeFilter(filter) {
+
+    countPolarWithEdgeFilter(filter: any) {
         return this.builtMeasureValuePolarContainers
             .reduce((p, c) => p + c.polarEdges.filter(filter).length, 0);
     }
-    filter(polarFilter) {
+
+    filter(polarFilter: PolarFilter) {
+
         const azimuthsCount = this.polarMeasureValue.getAzimuthsCount();
         const polarEdgesCount = this.polarMeasureValue.getPolarEdgesCount();
         const defaultDistanceBetweenInEdgeInMeters = this.polarMeasureValue.getDefaultDistance();
+
         const azimuthMin = typeof polarFilter.azimuthMin !== 'undefined' ? polarFilter.azimuthMin : 0;
         const azimuthMax = typeof polarFilter.azimuthMax !== 'undefined' ?
             Math.min(polarFilter.azimuthMax, azimuthsCount - 1) : azimuthsCount - 1;
         const edgeMin = typeof polarFilter.edgeMin !== 'undefined' ? polarFilter.edgeMin : 0;
         const edgeMax = typeof polarFilter.edgeMax !== 'undefined' ?
             Math.min(polarFilter.edgeMax, polarEdgesCount - 1) : polarEdgesCount - 1;
+
         const newMeasureValuePolarContainers = [];
         for (let azimuthIndex = azimuthMin; azimuthIndex <= azimuthMax; azimuthIndex++) {
             const azimuthInDegrees = azimuthIndex * 360 / azimuthsCount;
             const polarEdges = [];
             for (let edgeIndex = edgeMin; edgeIndex <= edgeMax; edgeIndex++) {
-                const polarValue = this.getPolarValue({ azimuthIndex, edgeIndex });
+                const polarValue = this.getPolarValue({azimuthIndex, edgeIndex});
                 polarEdges.push(polarValue.value);
             }
-            newMeasureValuePolarContainers.push(new MeasureValuePolarContainer_1.MeasureValuePolarContainer({
+            newMeasureValuePolarContainers.push(new MeasureValuePolarContainer({
                 azimuth: azimuthInDegrees,
                 distance: defaultDistanceBetweenInEdgeInMeters,
                 polarEdges,
                 edgeOffset: edgeMin
-            }));
+            }))
         }
+
         this.buildPolarFilter = polarFilter;
         this.builtMeasureValuePolarContainers = newMeasureValuePolarContainers;
     }
-    buildFromPolar() {
+
+    protected buildFromPolar() {
         if (!this.polarMeasureValue) {
             return [];
         }
-        const builtMeasureValuePolarContainers = [];
+
+        const builtMeasureValuePolarContainers: MeasureValuePolarContainer[] = [];
+
         const azimuthsCount = this.polarMeasureValue.getAzimuthsCount();
         const polarEdgesCount = this.polarMeasureValue.getPolarEdgesCount();
         const defaultDistanceBetweenInEdgeInMeters = this.polarMeasureValue.getDefaultDistance();
+
         const azimuthMin = typeof this.buildPolarFilter.azimuthMin !== 'undefined' ? this.buildPolarFilter.azimuthMin : 0;
         const azimuthMax = typeof this.buildPolarFilter.azimuthMax !== 'undefined' ? this.buildPolarFilter.azimuthMax : azimuthsCount - 1;
         const edgeMin = typeof this.buildPolarFilter.edgeMin !== 'undefined' ? this.buildPolarFilter.edgeMin : 0;
         const edgeMax = typeof this.buildPolarFilter.edgeMax !== 'undefined' ? this.buildPolarFilter.edgeMax : polarEdgesCount - 1;
+
         for (let azIndex = azimuthMin; azIndex <= azimuthMax; azIndex++) {
             const azimuthInDegrees = azIndex * 360 / azimuthsCount;
             const polarEdges = [];
             for (let edgeIndex = edgeMin; edgeIndex <= edgeMax; edgeIndex++) {
                 const distanceInMeters = defaultDistanceBetweenInEdgeInMeters * (edgeIndex + 1);
-                const polarValue = this.polarMeasureValue.getPolarValue({ azimuthInDegrees, distanceInMeters });
+                const polarValue = this.polarMeasureValue.getPolarValue({azimuthInDegrees, distanceInMeters});
                 polarEdges.push(polarValue.value);
             }
-            builtMeasureValuePolarContainers.push(new MeasureValuePolarContainer_1.MeasureValuePolarContainer({
+            builtMeasureValuePolarContainers.push(new MeasureValuePolarContainer({
                 azimuth: azimuthInDegrees,
                 distance: defaultDistanceBetweenInEdgeInMeters,
                 polarEdges,
                 edgeOffset: edgeMin
-            }));
+            }))
         }
+
         this.builtMeasureValuePolarContainers = builtMeasureValuePolarContainers;
     }
-    updatedAzimuth(azimuthIndexToUpdate) {
-        var _a;
+
+    protected updatedAzimuth(azimuthIndexToUpdate: number) {
         const azimuthsCount = this.polarMeasureValue.getAzimuthsCount();
-        const azimuthMin = typeof ((_a = this.buildPolarFilter) === null || _a === void 0 ? void 0 : _a.azimuthMin) !== 'undefined' ? this.buildPolarFilter.azimuthMin : 0;
+        const azimuthMin = typeof this.buildPolarFilter?.azimuthMin !== 'undefined' ? this.buildPolarFilter.azimuthMin : 0;
+
         const azimuthIndexAbsolute = azimuthIndexToUpdate - azimuthMin;
         const azimuthIndex1 = PolarMeasureValueMap.UpdateIndex(azimuthsCount, azimuthIndexAbsolute);
         const azimuthIndex2 = PolarMeasureValueMap.UpdateIndex(azimuthsCount, azimuthIndexToUpdate);
         const azimuthInDegrees = (azimuthIndex2) * 360 / azimuthsCount;
+
         if (azimuthIndex1 < 0) {
             console.warn('### raain-model > Map strange azimuthIndex:', azimuthIndex1);
         }
         if (azimuthInDegrees < 0 || azimuthInDegrees > 360) {
             console.warn('### raain-model > Map strange azimuthInDegrees:', azimuthInDegrees);
         }
-        return { azimuthIndex: azimuthIndex1, azimuthInDegrees };
+
+        return {azimuthIndex: azimuthIndex1, azimuthInDegrees};
     }
-    updatedEdge(edgeIndexToUpdate, measureValuePolarContainer, options) {
-        var _a;
+
+    protected updatedEdge(edgeIndexToUpdate: number,
+                          measureValuePolarContainer?: MeasureValuePolarContainer,
+                          options?: {
+                              reverse: boolean
+                          }) {
         let distance = this.polarMeasureValue.getDefaultDistance();
         if (measureValuePolarContainer) {
             distance = measureValuePolarContainer.getDistance();
         }
-        const edgeMin = typeof ((_a = this.buildPolarFilter) === null || _a === void 0 ? void 0 : _a.edgeMin) !== 'undefined' ? this.buildPolarFilter.edgeMin : 0;
+        const edgeMin = typeof this.buildPolarFilter?.edgeMin !== 'undefined' ? this.buildPolarFilter.edgeMin : 0;
+
         let edgeIndex = edgeIndexToUpdate - edgeMin;
         let distanceIndex = edgeIndexToUpdate + 1;
-        if (options === null || options === void 0 ? void 0 : options.reverse) {
+        if (options?.reverse) {
             edgeIndex = edgeIndexToUpdate + edgeMin;
             distanceIndex = edgeIndex + 1;
         }
+
         const distanceInMeters = distance * distanceIndex;
         if (distanceInMeters < 0) {
             console.warn('### raain-model > Map strange edgeIndex:', edgeIndex, distanceInMeters);
         }
+
         edgeIndex = Math.round(edgeIndex);
-        return { edgeIndex, distanceInMeters };
+
+        return {edgeIndex, distanceInMeters};
     }
-    iterateOnEachAzimuth(azimuthMin, azimuthMax, edgeMin, edgeMax, onEachValue) {
+
+    protected iterateOnEachAzimuth(azimuthMin: number, azimuthMax: number,
+                                   edgeMin: number, edgeMax: number,
+                                   onEachValue: (
+                                       polarValue: PolarValue,
+                                       azimuthIndex: number,
+                                       edgeIndex: number,
+                                       valueSetter: (newValue: number) => void
+                                   ) => void) {
+
         for (const measureValuePolarContainer of this.builtMeasureValuePolarContainers) {
             const azimuthInDegrees = measureValuePolarContainer.azimuth;
             const polarEdges = measureValuePolarContainer.polarEdges;
             const azimuthAbsoluteIndex = Math.round(azimuthInDegrees * this.polarMeasureValue.getAzimuthsCount() / 360);
-            if (azimuthAbsoluteIndex < azimuthMin)
-                continue;
-            if (azimuthMax < azimuthAbsoluteIndex)
-                break;
+            if (azimuthAbsoluteIndex < azimuthMin) continue;
+            if (azimuthMax < azimuthAbsoluteIndex) break;
+
             for (const [edgeIndex, value] of polarEdges.entries()) {
-                const updated = this.updatedEdge(edgeIndex, measureValuePolarContainer, { reverse: true });
+
+                const updated = this.updatedEdge(edgeIndex, measureValuePolarContainer, {reverse: true});
                 const edgeAbsoluteIndex = updated.edgeIndex;
                 const distanceInMeters = updated.distanceInMeters;
-                if (edgeAbsoluteIndex < edgeMin)
-                    continue;
-                if (edgeMax < edgeAbsoluteIndex)
-                    break;
-                const valueSetter = (newValue) => {
+                if (edgeAbsoluteIndex < edgeMin) continue;
+                if (edgeMax < edgeAbsoluteIndex) break;
+
+                const valueSetter = (newValue: number) => {
                     polarEdges[edgeIndex] = newValue;
                 };
-                onEachValue(new PolarValue_1.PolarValue({
-                    value,
-                    polarAzimuthInDegrees: azimuthInDegrees,
-                    polarDistanceInMeters: distanceInMeters
-                }), azimuthAbsoluteIndex, edgeAbsoluteIndex, valueSetter);
+
+                onEachValue(
+                    new PolarValue({
+                        value,
+                        polarAzimuthInDegrees: azimuthInDegrees,
+                        polarDistanceInMeters: distanceInMeters
+                    }),
+                    azimuthAbsoluteIndex,
+                    edgeAbsoluteIndex,
+                    valueSetter);
             }
         }
     }
-    iterateOnEachEdge(azimuthMin, azimuthMax, edgeMin, edgeMax, onEachValue) {
+
+    protected iterateOnEachEdge(azimuthMin: number, azimuthMax: number,
+                                edgeMin: number, edgeMax: number,
+                                onEachValue: (
+                                    polarValue: PolarValue,
+                                    azimuthIndex: number,
+                                    edgeIndex: number,
+                                    valueSetter: (newValue: number) => void
+                                ) => void) {
+
         for (let edge = edgeMin; edge <= edgeMax; edge++) {
             for (const measureValuePolarContainer of this.builtMeasureValuePolarContainers) {
                 const azimuthInDegrees = measureValuePolarContainer.azimuth;
                 const polarEdges = measureValuePolarContainer.polarEdges;
                 const azimuthAbsoluteIndex = Math.round(azimuthInDegrees * this.polarMeasureValue.getAzimuthsCount() / 360);
-                if (azimuthAbsoluteIndex < azimuthMin)
-                    continue;
-                if (azimuthMax < azimuthAbsoluteIndex)
-                    break;
+                if (azimuthAbsoluteIndex < azimuthMin) continue;
+                if (azimuthMax < azimuthAbsoluteIndex) break;
+
                 for (const [edgeIndex, value] of polarEdges.entries()) {
-                    const updated = this.updatedEdge(edgeIndex, measureValuePolarContainer, { reverse: true });
+
+                    const updated = this.updatedEdge(edgeIndex, measureValuePolarContainer, {reverse: true});
                     const edgeAbsoluteIndex = updated.edgeIndex;
                     const distanceInMeters = updated.distanceInMeters;
+
                     if (edge === edgeAbsoluteIndex) {
-                        const valueSetter = (newValue) => {
+                        const valueSetter = (newValue: number) => {
                             polarEdges[edgeIndex] = newValue;
                         };
-                        onEachValue(new PolarValue_1.PolarValue({
-                            value,
-                            polarAzimuthInDegrees: azimuthInDegrees,
-                            polarDistanceInMeters: distanceInMeters
-                        }), azimuthAbsoluteIndex, edgeAbsoluteIndex, valueSetter);
+
+                        onEachValue(
+                            new PolarValue({
+                                value,
+                                polarAzimuthInDegrees: azimuthInDegrees,
+                                polarDistanceInMeters: distanceInMeters
+                            }),
+                            azimuthAbsoluteIndex,
+                            edgeAbsoluteIndex,
+                            valueSetter);
                     }
                     if (edge < edgeAbsoluteIndex) {
                         break;
@@ -271,5 +350,3 @@ class PolarMeasureValueMap {
         }
     }
 }
-exports.PolarMeasureValueMap = PolarMeasureValueMap;
-//# sourceMappingURL=PolarMeasureValueMap.js.map

package/src/polar/PolarValue.ts

@@ -0,0 +1,16 @@
+export class PolarValue {
+    public value: number;
+    public polarAzimuthInDegrees: number;
+    public polarDistanceInMeters: number;
+
+    constructor(json: {
+        value: number,
+        polarAzimuthInDegrees: number,
+        polarDistanceInMeters: number
+    }) {
+        this.value = json.value;
+        this.polarAzimuthInDegrees = json.polarAzimuthInDegrees;
+        this.polarDistanceInMeters = json.polarDistanceInMeters;
+    }
+}
+

package/{polar/RadarPolarMeasureValue.js → src/polar/RadarPolarMeasureValue.ts}

@@ -1,29 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RadarPolarMeasureValue = void 0;
-const AbstractPolarMeasureValue_1 = require("./AbstractPolarMeasureValue");
-const PolarMeasureValue_1 = require("./PolarMeasureValue");
-const MeasureValuePolarContainer_1 = require("./MeasureValuePolarContainer");
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {AbstractPolarMeasureValue} from './AbstractPolarMeasureValue';
+import {PolarMeasureValue} from './PolarMeasureValue';
+import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
+
 /**
  * Radar with polar value containers
  */
-class RadarPolarMeasureValue extends AbstractPolarMeasureValue_1.AbstractPolarMeasureValue {
-    constructor(json) {
+export class RadarPolarMeasureValue extends AbstractPolarMeasureValue implements IPolarMeasureValue {
+
+    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: {
+        polarMeasureValue: RadarPolarMeasureValue | PolarMeasureValue | string,
+        angle: number
+        axis: number
+    }) {
         super(json);
+
         if (json.polarMeasureValue instanceof RadarPolarMeasureValue) {
             this.angle = json.polarMeasureValue.angle;
             this.axis = json.polarMeasureValue.axis;
             return;
         }
+
         if (typeof json.polarMeasureValue === 'string') {
             const object = JSON.parse(json.polarMeasureValue);
             this.angle = typeof json.angle !== 'undefined' ? json.angle : object.angle;
             this.axis = typeof json.axis !== 'undefined' ? json.axis : object.axis;
             return;
         }
+
         this.angle = json.angle;
         this.axis = json.axis;
     }
+
     /**
      * A fake image to give an example of format needed, made of:
      *  - 2 axis: horizontal + vertical
@@ -31,9 +42,10 @@ class RadarPolarMeasureValue extends AbstractPolarMeasureValue_1.AbstractPolarMe
      *  - 720 azimuth with a step of 0.5°
      *  - 250 gate with a step of 1KM
      */
-    static BuildFakeRadarPolarMeasureValues(movementFrom0To90 = 0) {
-        const radarPolarMeasureValues = [];
-        const getMovementValue = (az, dis) => {
+    public static BuildFakeRadarPolarMeasureValues(movementFrom0To90 = 0): RadarPolarMeasureValue[] {
+        const radarPolarMeasureValues: RadarPolarMeasureValue[] = [];
+
+        const getMovementValue = (az: number, dis: number) => {
             const sin = Math.sin(az * (Math.PI / 180));
             const tolerance = 20;
             let val = 0;
@@ -44,9 +56,10 @@ class RadarPolarMeasureValue extends AbstractPolarMeasureValue_1.AbstractPolarMe
             }
             return val;
         };
+
         const azimuthsCount = 360 * 2;
         const polarEdgesCount = 250;
-        for (let axis = 0; axis <= 90; axis += 90) { // 2 axis: horizontal + vertical
+        for (let axis = 0; axis <= 90; axis += 90) {    // 2 axis: horizontal + vertical
             for (let angle = 0.4; angle < 3; angle++) { // 3 sites: 0.4°, 1.4°, 2.4°
                 const value = {
                     polarMeasureValue: null,
@@ -54,37 +67,37 @@ class RadarPolarMeasureValue extends AbstractPolarMeasureValue_1.AbstractPolarMe
                     angle
                 };
                 const measureValuePolarContainers = [];
-                for (let azimuth = 0; azimuth < (azimuthsCount / 2); azimuth += 0.5) { // 0.5° azimuth
+                for (let azimuth = 0; azimuth < (azimuthsCount / 2); azimuth += 0.5) {  // 0.5° azimuth
                     const data = [];
                     for (let distance = 0; distance < polarEdgesCount; distance++) {
                         const num = Math.round(angle * getMovementValue(azimuth, distance));
                         data.push(num);
                     }
-                    const measureValuePolarContainer = new MeasureValuePolarContainer_1.MeasureValuePolarContainer({
+                    const measureValuePolarContainer = new MeasureValuePolarContainer({
                         azimuth,
                         distance: 1000, // 1KM gate = 1000 meters
                         polarEdges: data,
                     });
                     measureValuePolarContainers.push(measureValuePolarContainer);
                 }
-                value.polarMeasureValue = new PolarMeasureValue_1.PolarMeasureValue({ measureValuePolarContainers, azimuthsCount, polarEdgesCount });
+                value.polarMeasureValue = new PolarMeasureValue({measureValuePolarContainers, azimuthsCount, polarEdgesCount});
                 const radarPolarMeasureValue = new RadarPolarMeasureValue(value);
                 radarPolarMeasureValues.push(radarPolarMeasureValue);
             }
         }
         return radarPolarMeasureValues;
     }
-    toJSON(options = {
+
+    public toJSON(options = {
         stringify: false
-    }) {
+    }): any {
         const json = super.toJSON(options);
         json.angle = this.angle;
         json.axis = this.axis;
         return json;
     }
-    toJSONWithPolarStringified() {
-        return this.toJSON({ stringify: true });
+
+    public toJSONWithPolarStringified(): any {
+        return this.toJSON({stringify: true});
     }
 }
-exports.RadarPolarMeasureValue = RadarPolarMeasureValue;
-//# sourceMappingURL=RadarPolarMeasureValue.js.map

package/src/polar/RainPolarMeasureValue.ts

@@ -0,0 +1,57 @@
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {IVersion} from '../organization';
+import {AbstractPolarMeasureValue} from './AbstractPolarMeasureValue';
+import {PolarMeasureValue} from './PolarMeasureValue';
+
+/**
+ * Computed Rain with polar value containers
+ */
+export class RainPolarMeasureValue extends AbstractPolarMeasureValue implements IPolarMeasureValue, IVersion {
+
+    private readonly version: string;
+
+    constructor(json: {
+        polarMeasureValue: RainPolarMeasureValue | PolarMeasureValue | string,
+        version?: string
+    }) {
+        super(json);
+
+        if (json.polarMeasureValue instanceof RainPolarMeasureValue) {
+            this.version = json.polarMeasureValue.version;
+            return;
+        }
+
+        this.version = json.version;
+    }
+
+    static From(obj: IPolarMeasureValue | any): RainPolarMeasureValue {
+        let version: string,
+            polarMeasureValue: PolarMeasureValue;
+
+        if (typeof obj.version === 'string') {
+            version = obj.version;
+        }
+
+        if (typeof obj.polarMeasureValue !== 'undefined') {
+            polarMeasureValue = obj.polarMeasureValue;
+        }
+
+        return new RainPolarMeasureValue({polarMeasureValue, version});
+    }
+
+    public toJSON(options = {
+        stringify: false
+    }): any {
+        const json: any = super.toJSON(options);
+        json.version = this.version;
+        return json;
+    }
+
+    public toJSONWithPolarStringified(): any {
+        return this.toJSON({stringify: true});
+    }
+
+    public getVersion(): string {
+        return this.version;
+    }
+}